### Infernal Robotics API Example (C)

Source: https://krpc.github.io/krpc/_sources/cnano/api/infernal-robotics.rst

Demonstrates how to get a control group, list servo names and positions, and move servos using the Infernal Robotics API. This example requires the Infernal Robotics Next mod to be installed.

```c
#include <krpc/krpc.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
    krpc_connection_t connection = krpc_connect("InfernalRoboticsExample");

    // Get the Infernal Robotics service
    infernal_robotics_service_t ir = infernal_robotics_get_service(connection);

    // Get the control group named "MyGroup"
    infernal_robotics_control_group_t group = infernal_robotics_get_control_group_by_name(ir, "MyGroup");

    // Print out the names and positions of all servos in the group
    size_t num_servos = infernal_robotics_control_group_get_servos_count(group);
    for (size_t i = 0; i < num_servos; ++i) {
        infernal_robotics_servo_t servo = infernal_robotics_control_group_get_servos(group)[i];
        printf("Servo: %s, Position: %f\n", infernal_robotics_servo_get_name(servo), infernal_robotics_servo_get_position(servo));
    }

    // Move all servos to the right for 1 second
    infernal_robotics_control_group_set_target_position(group, 1.0);
    infernal_robotics_control_group_move_to_target_position(group);
    krpc_sleep(connection, 1.0);

    krpc_disconnect(connection);
    return 0;
}
```

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

### Connect and Get Server Status (JavaScript)

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

This example connects to the kRPC server, invokes the GetStatus RPC, decodes the response, and prints the server version. It requires 'ws', 'protobufjs', and 'bytebuffer' libraries.

```javascript
var websocket = require('ws');
var protobufjs = require('protobufjs')
var ByteBuffer = require('bytebuffer')
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 = (e) => {
  console.log('Successfully connected')
  let call = new proto.krpc.schema.ProcedureCall('KRPC', 'GetStatus');
  let request = new proto.krpc.schema.Request([call]);
  rpcConn.send(request.toArrayBuffer());
  rpcConn.onmessage = (e) => {
    let response = proto.krpc.schema.Response.decode(e.data)
    let status = proto.krpc.schema.Status.decode(response.results[0].value)
    console.log(status);
    process.exit(0);
  };
};

```

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

### Connect, Stream Data, and Get Server Status (JavaScript)

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

This example demonstrates connecting to the kRPC server, establishing a stream connection, and receiving data updates. It requires 'ws' and 'protobufjs' libraries and handles client identification for stream connections.

```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);
  };
};

```

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

### Connect to kRPC Server and Get Version (C)

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

Connects to the kRPC server, queries its version, and prints it to the console. This example is intended for POSIX systems like Linux. It uses the krpc_connect function to establish the connection.

```c
#include <stdio.h>
#include <krpc/client.h>

int main() {
    krpc_connection_t conn;
    krpc_error_t err;

    // Connect to the server (replace "/dev/ttyACM0" with your serial port)
    err = krpc_connect(&conn, "/dev/ttyACM0");
    if (err != KRPC_OK) {
        fprintf(stderr, "Failed to connect: %s\n", krpc_get_error(err));
        return 1;
    }

    // Query server version
    const char *version;
    err = krpc_get_version(&conn, &version);
    if (err != KRPC_OK) {
        fprintf(stderr, "Failed to get version: %s\n", krpc_get_error(err));
        krpc_close(&conn);
        return 1;
    }

    printf("kRPC Server Version: %s\n", version);

    // Close the connection
    krpc_close(&conn);

    return 0;
}

```

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

### C# Example: Infernal Robotics Servo Control

Source: https://krpc.github.io/krpc/_sources/csharp/api/infernal-robotics.rst

This example demonstrates how to interact with the Infernal Robotics API in C#. It retrieves a control group, lists servo names and positions, and then moves all servos to the right for a specified duration. This requires the Infernal Robotics Next mod to be installed.

```csharp
using System;
using KRPC.Client.Services.InfernalRobotics;

public class InfernalRoboticsExample
{
    public static void Main(string[] args)
    {
        // Assuming you have a KRPC connection established
        // var connection = KRPC.Client.Connection.Connect("localhost");
        // var krpc = new KRPC.Client.KRPC(connection);

        // Replace with your actual KRPC client object
        var krpc = GetKrpcClient(); 

        // Get the control group named "MyGroup"
        var group = krpc.InfernalRobotics().GetControlGroup("MyGroup");

        // Print out the names and positions of all servos in the group
        Console.WriteLine($"Servos in group '{group.Name}':");
        foreach (var servo in group.Servos)
        {
            Console.WriteLine($"  - {servo.Name}: Position {servo.Position}");
        }

        // Move all servos to the right for 1 second
        Console.WriteLine("Moving servos to the right for 1 second...");
        group.MoveTo(1.0f, 1.0f);
        System.Threading.Thread.Sleep(1000);
        group.Stop();

        Console.WriteLine("Servos moved.");
    }

    // Placeholder for getting a KRPC client instance
    private static KRPC.Client.KRPC GetKrpcClient()
    {
        // In a real application, you would establish a connection to KRPC here
        // For demonstration purposes, returning a mock or null.
        throw new NotImplementedException("KRPC connection not implemented in this example.");
    }
}
```

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

### Build and Install kRPC Client with Configure (Bash)

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

Builds and installs the kRPC client library and headers using the configure script after dependencies are installed. Includes steps for configuration, compilation, installation, and dynamic linker update.

```bash
./configure
make
sudo make install
sudo ldconfig
```

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

### Infernal Robotics API Example Script (Python)

Source: https://krpc.github.io/krpc/_sources/python/api/infernal-robotics.rst

This Python script demonstrates how to interact with the Infernal Robotics API. It retrieves a servo group, lists its servos, and then moves them. This requires the Infernal Robotics Next mod to be installed.

```python
import krpc.client
import time

# Connect to the kRPC server
conn = krpc.client.connect()

# Get the Infernal Robotics service
ir_service = conn.get_service('InfernalRobotics')

# Get the control group named "MyGroup"
control_group = ir_service.get_control_group("MyGroup")

# Print names and positions of servos in the group
print("Servos in group:")
for servo in control_group.servos:
    print(f"  Name: {servo.name}, Position: {servo.position}")

# Move all servos to the right for 1 second
print("Moving servos to the right...")
control_group.move_to_position(1.0, 1.0)
time.sleep(1)
print("Done.")
```

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

### Interact with Infernal Robotics Next using C++

Source: https://krpc.github.io/krpc/cpp/api/infernal-robotics

This C++ example demonstrates how to use the InfernalRobotics API to connect to kRPC, access a specific servo group by name, list servos within the group, and control their movement. It requires the kRPC client library and assumes Infernal Robotics Next is installed in the game.

```C++
#include <iostream>
#include <vector>
#include <thread>
#include <krpc.hpp>
#include <krpc/services/space_center.hpp>
#include <krpc/services/infernal_robotics.hpp>

using SpaceCenter = krpc::services::SpaceCenter;
using InfernalRobotics = krpc::services::InfernalRobotics;

int main() {
  auto conn = krpc::connect("InfernalRobotics Example");
  SpaceCenter space_center(&conn);
  InfernalRobotics infernal_robotics(&conn);

  InfernalRobotics::ServoGroup group = infernal_robotics.servo_group_with_name(space_center.active_vessel(), "MyGroup");
  if (group == InfernalRobotics::ServoGroup())
    std::cout << "Group not found" << std::endl;

  std::vector<InfernalRobotics::Servo> servos = group.servos();
  for (auto servo : servos)
    std::cout << servo.name() << " " << servo.position() << std::endl;

  group.move_right();
  std::this_thread::sleep_for(std::chrono::seconds(1));
  group.stop();
}

```

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

### Install kRPC Python Module (Linux)

Source: https://krpc.github.io/krpc/_sources/getting-started.rst

Installs the kRPC Python module using pip on Linux. Assumes Python and pip are already installed.

```bash
pip install krpc
```

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

### Install kRPC Python Module (Windows)

Source: https://krpc.github.io/krpc/_sources/getting-started.rst

Installs the kRPC Python module using pip on Windows. Ensure Python and pip are installed and accessible from the command prompt.

```bash
C:\Python310\Scripts\pip.exe install krpc
```

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

### Connect and Prepare Rocket for Launch (C#, C++, Java, Lua, Python)

Source: https://krpc.github.io/krpc/_sources/tutorials/launch-into-orbit.rst

Connects to the kRPC server, retrieves the active vessel, sets up flight telemetry streams, and prepares the rocket for launch. This code forms the initial setup for the launch sequence.

```csharp
using System;
using System.Collections.Generic;
using KRPC.Client.Services.SpaceCenter;
using KRPC.Client.Services.SpaceCenter.Models;

public class LaunchIntoOrbit
{
    public static void Main(string[] args)
    {
        // Connect to kRPC server
        var connection = new KRPC.Client.Connection("localhost");
        var spaceCenter = new KRPC.Client.Services.SpaceCenter.SpaceCenter(connection);
        Console.WriteLine($"Connected to kRPC Version {spaceCenter.Version}");

        // Get the active vessel
        var vessel = spaceCenter.ActiveVessel;
        Console.WriteLine($"Vessel: {vessel.Name}");

        // Set up streams for flight telemetry
        var streams = new Dictionary<Stream, StreamHandle>();
        streams.Add(Stream.Vessel.Name, vessel.NameStream());
        streams.Add(Stream.Vessel.Type, vessel.TypeStream());
        streams.Add(Stream.Vessel.Mass.Total, vessel.Mass.TotalStream());
        streams.Add(Stream.Vessel.Orbit.ApoapsisAltitude, vessel.Orbit.ApoapsisAltitudeStream());
        streams.Add(Stream.Vessel.Orbit.PeriapsisAltitude, vessel.Orbit.PeriapsisAltitudeStream());
        streams.Add(Stream.Vessel.Flight(vessel.SurfaceReferenceFrame).
            TrueAltitude, vessel.Flight(vessel.SurfaceReferenceFrame).TrueAltitudeStream());
        streams.Add(Stream.Vessel.Flight(vessel.SurfaceReferenceFrame).
            VerticalSpeed, vessel.Flight(vessel.SurfaceReferenceFrame).VerticalSpeedStream());
        streams.Add(Stream.Vessel.Flight(vessel.SurfaceReferenceFrame).
            HorizontalSpeed, vessel.Flight(vessel.SurfaceReferenceFrame).HorizontalSpeedStream());
        streams.Add(Stream.Vessel.Flight(vessel.SurfaceReferenceFrame).
            GForce, vessel.Flight(vessel.SurfaceReferenceFrame).GForceStream());
        streams.Add(Stream.Vessel.Control.Throttle, vessel.Control.ThrottleStream());
        streams.Add(Stream.Vessel.Control.RCS, vessel.Control.RCSStream());
        streams.Add(Stream.Vessel.Control.SAS, vessel.Control.SASStream());
        streams.Add(Stream.Vessel.Control.Gear, vessel.Control.GearStream());
        streams.Add(Stream.Vessel.Control.Brakes, vessel.Control.BrakesStream());
        streams.Add(Stream.Vessel.Control.Lights, vessel.Control.LightsStream());
        streams.Add(Stream.Vessel.Control.Antennas, vessel.Control.AntennasStream());
        streams.Add(Stream.Vessel.Control.Radiators, vessel.Control.RadiatorsStream());
        streams.Add(Stream.Vessel.Control.SolarPanels, vessel.Control.SolarPanelsStream());
        streams.Add(Stream.Vessel.Control.Cover, vessel.Control.CoverStream());
        streams.Add(Stream.Vessel.Control.Abort, vessel.Control.AbortStream());
        streams.Add(Stream.Vessel.Control.ExecuteNextStage, vessel.Control.ExecuteNextStageStream());
        streams.Add(Stream.Vessel.Control.NextStage, vessel.Control.NextStageStream());
        streams.Add(Stream.Vessel.Control.PreviousStage, vessel.Control.PreviousStageStream());
        streams.Add(Stream.Vessel.Control.Relaunch, vessel.Control.RelaunchStream());
        streams.Add(Stream.Vessel.Control.Undock, vessel.Control.UndockStream());
        streams.Add(Stream.Vessel.Control.Dock, vessel.Control.DockStream());
        streams.Add(Stream.Vessel.Control.Arm, vessel.Control.ArmStream());
        streams.Add(Stream.Vessel.Control.Disarm, vessel.Control.DisarmStream());
        streams.Add(Stream.Vessel.Control.ActivateNextStage, vessel.Control.ActivateNextStageStream());
        streams.Add(Stream.Vessel.Control.Decouple, vessel.Control.DecoupleStream());
        streams.Add(Stream.Vessel.Control.Eject, vessel.Control.EjectStream());
        streams.Add(Stream.Vessel.Control.Retract, vessel.Control.RetractStream());
        streams.Add(Stream.Vessel.Control.Deploy, vessel.Control.DeployStream());
        streams.Add(Stream.Vessel.Control.Toggle, vessel.Control.ToggleStream());
        streams.Add(Stream.Vessel.Control.Engage, vessel.Control.EngageStream());
        streams.Add(Stream.Vessel.Control.Disengage, vessel.Control.DisengageStream());
        streams.Add(Stream.Vessel.Control.SetRCS, vessel.Control.SetRCSStream());
        streams.Add(Stream.Vessel.Control.SetSAS, vessel.Control.SetSASStream());
        streams.Add(Stream.Vessel.Control.SetThrottle, vessel.Control.SetThrottleStream());
        streams.Add(Stream.Vessel.Control.SetLights, vessel.Control.SetLightsStream());
        streams.Add(Stream.Vessel.Control.SetSolarPanels, vessel.Control.SetSolarPanelsStream());
        streams.Add(Stream.Vessel.Control.SetRadiators, vessel.Control.SetRadiatorsStream());
        streams.Add(Stream.Vessel.Control.SetCover, vessel.Control.SetCoverStream());
        streams.Add(Stream.Vessel.Control.SetAntennas, vessel.Control.SetAntennasStream());
        streams.Add(Stream.Vessel.Control.SetGear, vessel.Control.SetGearStream());
        streams.Add(Stream.Vessel.Control.SetBrakes, vessel.Control.SetBrakesStream());
        streams.Add(Stream.Vessel.Control.SetAbort, vessel.Control.SetAbortStream());
        streams.Add(Stream.Vessel.Control.SetDock, vessel.Control.SetDockStream());
        streams.Add(Stream.Vessel.Control.SetUndock, vessel.Control.SetUndockStream());
        streams.Add(Stream.Vessel.Control.SetArm, vessel.Control.SetArmStream());
        streams.Add(Stream.Vessel.Control.SetDisarm, vessel.Control.SetDisarmStream());
        streams.Add(Stream.Vessel.Control.SetEject, vessel.Control.SetEjectStream());
        streams.Add(Stream.Vessel.Control.SetRetract, vessel.Control.SetRetractStream());
        streams.Add(Stream.Vessel.Control.SetDeploy, vessel.Control.SetDeployStream());
        streams.Add(Stream.Vessel.Control.SetToggle, vessel.Control.SetToggleStream());
        streams.Add(Stream.Vessel.Control.SetEngage, vessel.Control.SetEngageStream());
        streams.Add(Stream.Vessel.Control.SetDisengage, vessel.Control.SetDisengageStream());
        streams.Add(Stream.Vessel.Control.SetNextStage, vessel.Control.SetNextStageStream());
        streams.Add(Stream.Vessel.Control.SetPreviousStage, vessel.Control.SetPreviousStageStream());
        streams.Add(Stream.Vessel.Control.SetRelaunch, vessel.Control.SetRelaunchStream());
        streams.Add(Stream.Vessel.Control.SetDecouple, vessel.Control.SetDecoupleStream());
        streams.Add(Stream.Vessel.Control.SetActivateNextStage, vessel.Control.SetActivateNextStageStream());
        streams.Add(Stream.Vessel.Control.SetExecuteNextStage, vessel.Control.SetExecuteNextStageStream());

        // Prepare rocket for launch
        vessel.Control.RCS = true;
        vessel.Control.SAS = true;
        vessel.Control.Gear = true;
        vessel.Control.Lights = true;
        vessel.Control.Antennas = true;
        vessel.Control.Radiators = true;
        vessel.Control.SolarPanels = true;
        vessel.Control.Cover = true;
        vessel.Control.Abort = true;
        vessel.Control.Dock = true;
        vessel.Control.Arm = true;
        vessel.Control.Disarm = true;
        vessel.Control.Eject = true;
        vessel.Control.Retract = true;
        vessel.Control.Deploy = true;
        vessel.Control.Toggle = true;
        vessel.Control.Engage = true;
        vessel.Control.Disengage = true;
        vessel.Control.NextStage = true;
        vessel.Control.PreviousStage = true;
        vessel.Control.Relaunch = true;
        vessel.Control.Undock = true;
        vessel.Control.Decouple = true;
        vessel.Control.ActivateNextStage = true;
        vessel.Control.ExecuteNextStage = true;

        // Wait for streams to be updated
        connection.WaitUntilStreamsAreReady();
    }
}

```

```cpp
#include <iostream>
#include <krpc/client.hpp>
#include <krpc/services/space_center.hpp>

int main() {
    // Connect to kRPC server
    krpc::Client client("localhost");
    krpc.services::space_center::SpaceCenter sc(client);
    std::cout << "Connected to kRPC Version " << sc.get_version() << std::endl;

    // Get the active vessel
    auto vessel = sc.get_active_vessel();
    std::cout << "Vessel: " << vessel.get_name() << std::endl;

    // Set up streams for flight telemetry
    std::vector<krpc::Stream> streams;
    streams.push_back(vessel.get_name_stream());
    streams.push_back(vessel.get_type_stream());
    streams.push_back(vessel.get_mass().get_total_stream());
    streams.push_back(vessel.get_orbit().get_apoapsis_altitude_stream());
    streams.push_back(vessel.get_orbit().get_periapsis_altitude_stream());
    streams.push_back(vessel.get_flight(vessel.get_surface_reference_frame()).get_true_altitude_stream());
    streams.push_back(vessel.get_flight(vessel.get_surface_reference_frame()).get_vertical_speed_stream());
    streams.push_back(vessel.get_flight(vessel.get_surface_reference_frame()).get_horizontal_speed_stream());
    streams.push_back(vessel.get_flight(vessel.get_surface_reference_frame()).get_g_force_stream());
    streams.push_back(vessel.get_control().get_throttle_stream());
    streams.push_back(vessel.get_control().get_rcs_stream());
    streams.push_back(vessel.get_control().get_sas_stream());
    streams.push_back(vessel.get_control().get_gear_stream());
    streams.push_back(vessel.get_control().get_brakes_stream());
    streams.push_back(vessel.get_control().get_lights_stream());
    streams.push_back(vessel.get_control().get_antennas_stream());
    streams.push_back(vessel.get_control().get_radiators_stream());
    streams.push_back(vessel.get_control().get_solar_panels_stream());
    streams.push_back(vessel.get_control().get_cover_stream());
    streams.push_back(vessel.get_control().get_abort_stream());
    streams.push_back(vessel.get_control().get_execute_next_stage_stream());
    streams.push_back(vessel.get_control().get_next_stage_stream());
    streams.push_back(vessel.get_control().get_previous_stage_stream());
    streams.push_back(vessel.get_control().get_relaunch_stream());
    streams.push_back(vessel.get_control().get_undock_stream());
    streams.push_back(vessel.get_control().get_dock_stream());
    streams.push_back(vessel.get_control().get_arm_stream());
    streams.push_back(vessel.get_control().get_disarm_stream());
    streams.push_back(vessel.get_control().get_activate_next_stage_stream());
    streams.push_back(vessel.get_control().get_decouple_stream());
    streams.push_back(vessel.get_control().get_eject_stream());
    streams.push_back(vessel.get_control().get_retract_stream());
    streams.push_back(vessel.get_control().get_deploy_stream());
    streams.push_back(vessel.get_control().get_toggle_stream());
    streams.push_back(vessel.get_control().get_engage_stream());
    streams.push_back(vessel.get_control().get_disengage_stream());
    streams.push_back(vessel.get_control().get_set_rcs_stream());
    streams.push_back(vessel.get_control().get_set_sas_stream());
    streams.push_back(vessel.get_control().get_set_throttle_stream());
    streams.push_back(vessel.get_control().get_set_lights_stream());
    streams.push_back(vessel.get_control().get_set_solar_panels_stream());
    streams.push_back(vessel.get_control().get_set_radiators_stream());
    streams.push_back(vessel.get_control().get_set_cover_stream());
    streams.push_back(vessel.get_control().get_set_antennas_stream());
    streams.push_back(vessel.get_control().get_set_gear_stream());
    streams.push_back(vessel.get_control().get_set_brakes_stream());
    streams.push_back(vessel.get_control().get_set_abort_stream());
    streams.push_back(vessel.get_control().get_set_dock_stream());
    streams.push_back(vessel.get_control().get_set_undock_stream());
    streams.push_back(vessel.get_control().get_set_arm_stream());
    streams.push_back(vessel.get_control().get_set_disarm_stream());
    streams.push_back(vessel.get_control().get_set_eject_stream());
    streams.push_back(vessel.get_control().get_set_retract_stream());
    streams.push_back(vessel.get_control().get_set_deploy_stream());
    streams.push_back(vessel.get_control().get_set_toggle_stream());
    streams.push_back(vessel.get_control().get_set_engage_stream());
    streams.push_back(vessel.get_control().get_set_disengage_stream());
    streams.push_back(vessel.get_control().get_set_next_stage_stream());
    streams.push_back(vessel.get_control().get_set_previous_stage_stream());
    streams.push_back(vessel.get_control().get_set_relaunch_stream());
    streams.push_back(vessel.get_control().get_set_decouple_stream());
    streams.push_back(vessel.get_control().get_set_activate_next_stage_stream());
    streams.push_back(vessel.get_control().get_set_execute_next_stage_stream());

    // Prepare rocket for launch
    vessel.get_control().set_rcs(true);
    vessel.get_control().set_sas(true);
    vessel.get_control().set_gear(true);
    vessel.get_control().set_lights(true);
    vessel.get_control().set_antennas(true);
    vessel.get_control().set_radiators(true);
    vessel.get_control().set_solar_panels(true);
    vessel.get_control().set_cover(true);
    vessel.get_control().set_abort(true);
    vessel.get_control().set_dock(true);
    vessel.get_control().set_arm(true);
    vessel.get_control().set_disarm(true);
    vessel.get_control().set_eject(true);
    vessel.get_control().set_retract(true);
    vessel.get_control().set_deploy(true);
    vessel.get_control().set_toggle(true);
    vessel.get_control().set_engage(true);
    vessel.get_control().set_disengage(true);
    vessel.get_control().set_next_stage(true);
    vessel.get_control().set_previous_stage(true);
    vessel.get_control().set_relaunch(true);
    vessel.get_control().set_undock(true);
    vessel.get_control().set_decouple(true);
    vessel.get_control().set_activate_next_stage(true);
    vessel.get_control().set_execute_next_stage(true);

    // Wait for streams to be updated
    client.wait_for_streams_to_be_ready();

    return 0;
}

```

```java
import krpc.client.Connection;
import krpc.client.RPCException;
import krpc.client.services.krpc.schema.StreamHandle;
import krpc.client.services.space_center.SpaceCenter;
import krpc.client.services.space_center.Vessel;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class LaunchIntoOrbit {

    public static void main(String[] args) throws IOException, RPCException {
        // Connect to kRPC server
        Connection connection = new Connection("localhost");
        SpaceCenter spaceCenter = new SpaceCenter(connection);
        System.out.println("Connected to kRPC Version " + spaceCenter.getVersion());

        // Get the active vessel
        Vessel vessel = spaceCenter.getActiveVessel();
        System.out.println("Vessel: " + vessel.getName());

        // Set up streams for flight telemetry
        Map<String, StreamHandle> streams = new HashMap<>();
        streams.put("vessel.name", vessel.nameStream(connection.getExecutor()));
        streams.put("vessel.type", vessel.typeStream(connection.getExecutor()));
        streams.put("vessel.mass.total", vessel.mass.totalStream(connection.getExecutor()));
        streams.put("vessel.orbit.apoapsis_altitude", vessel.orbit.apoapsisAltitudeStream(connection.getExecutor()));
        streams.put("vessel.orbit.periapsis_altitude", vessel.orbit.periapsisAltitudeStream(connection.getExecutor()));
        streams.put("vessel.flight.true_altitude", vessel.flight.trueAltitudeStream(vessel.getSurfaceReferenceFrame(), connection.getExecutor()));
        streams.put("vessel.flight.vertical_speed", vessel.flight.verticalSpeedStream(vessel.getSurfaceReferenceFrame(), connection.getExecutor()));
        streams.put("vessel.flight.horizontal_speed", vessel.flight.horizontalSpeedStream(vessel.getSurfaceReferenceFrame(), connection.getExecutor()));
        streams.put("vessel.flight.g_force", vessel.flight.gForceStream(vessel.getSurfaceReferenceFrame(), connection.getExecutor()));
        streams.put("vessel.control.throttle", vessel.control.throttleStream(connection.getExecutor()));
        streams.put("vessel.control.rcs", vessel.control.rcsStream(connection.getExecutor()));
        streams.put("vessel.control.sas", vessel.control.sasStream(connection.getExecutor()));
        streams.put("vessel.control.gear", vessel.control.gearStream(connection.getExecutor()));
        streams.put("vessel.control.brakes", vessel.control.brakesStream(connection.getExecutor()));
        streams.put("vessel.control.lights", vessel.control.lightsStream(connection.getExecutor()));
        streams.put("vessel.control.antennas", vessel.control.antennasStream(connection.getExecutor()));
        streams.put("vessel.control.radiators", vessel.control.radiatorsStream(connection.getExecutor()));
        streams.put("vessel.control.solar_panels", vessel.control.solarPanelsStream(connection.getExecutor()));
        streams.put("vessel.control.cover", vessel.control.coverStream(connection.getExecutor()));
        streams.put("vessel.control.abort", vessel.control.abortStream(connection.getExecutor()));
        streams.put("vessel.control.execute_next_stage", vessel.control.executeNextStageStream(connection.getExecutor()));
        streams.put("vessel.control.next_stage", vessel.control.nextStageStream(connection.getExecutor()));
        streams.put("vessel.control.previous_stage", vessel.control.previousStageStream(connection.getExecutor()));
        streams.put("vessel.control.relaunch", vessel.control.relaunchStream(connection.getExecutor()));
        streams.put("vessel.control.undock", vessel.control.undockStream(connection.getExecutor()));
        streams.put("vessel.control.dock", vessel.control.dockStream(connection.getExecutor()));
        streams.put("vessel.control.arm", vessel.control.armStream(connection.getExecutor()));
        streams.put("vessel.control.disarm", vessel.control.disarmStream(connection.getExecutor()));
        streams.put("vessel.control.activate_next_stage", vessel.control.activateNextStageStream(connection.getExecutor()));
        streams.put("vessel.control.decouple", vessel.control.decoupleStream(connection.getExecutor()));
        streams.put("vessel.control.eject", vessel.control.ejectStream(connection.getExecutor()));
        streams.put("vessel.control.retract", vessel.control.retractStream(connection.getExecutor()));
        streams.put("vessel.control.deploy", vessel.control.deployStream(connection.getExecutor()));
        streams.put("vessel.control.toggle", vessel.control.toggleStream(connection.getExecutor()));
        streams.put("vessel.control.engage", vessel.control.engageStream(connection.getExecutor()));
        streams.put("vessel.control.disengage", vessel.control.disengageStream(connection.getExecutor()));
        streams.put("vessel.control.set_rcs", vessel.control.setRCSStream(connection.getExecutor()));
        streams.put("vessel.control.set_sas", vessel.control.setSASStream(connection.getExecutor()));
        streams.put("vessel.control.set_throttle", vessel.control.setThrottleStream(connection.getExecutor()));
        streams.put("vessel.control.set_lights", vessel.control.setLightsStream(connection.getExecutor()));
        streams.put("vessel.control.set_solar_panels", vessel.control.setSolarPanelsStream(connection.getExecutor()));
        streams.put("vessel.control.set_radiators", vessel.control.setRadiatorsStream(connection.getExecutor()));
        streams.put("vessel.control.set_cover", vessel.control.setCoverStream(connection.getExecutor()));
        streams.put("vessel.control.set_antennas", vessel.control.setAntennasStream(connection.getExecutor()));
        streams.put("vessel.control.set_gear", vessel.control.setGearStream(connection.getExecutor()));
        streams.put("vessel.control.set_brakes", vessel.control.setBrakesStream(connection.getExecutor()));
        streams.put("vessel.control.set_abort", vessel.control.setAbortStream(connection.getExecutor()));
        streams.put("vessel.control.set_dock", vessel.control.setDockStream(connection.getExecutor()));
        streams.put("vessel.control.set_undock", vessel.control.setUndockStream(connection.getExecutor()));
        streams.put("vessel.control.set_arm", vessel.control.setArmStream(connection.getExecutor()));
        streams.put("vessel.control.set_disarm", vessel.control.setDisarmStream(connection.getExecutor()));
        streams.put("vessel.control.set_eject", vessel.control.setEjectStream(connection.getExecutor()));
        streams.put("vessel.control.set_retract", vessel.control.setRetractStream(connection.getExecutor()));
        streams.put("vessel.control.set_deploy", vessel.control.setDeployStream(connection.getExecutor()));
        streams.put("vessel.control.set_toggle", vessel.control.setToggleStream(connection.getExecutor()));
        streams.put("vessel.control.set_engage", vessel.control.setEngageStream(connection.getExecutor()));
        streams.put("vessel.control.set_disengage", vessel.control.setDisengageStream(connection.getExecutor()));
        streams.put("vessel.control.set_next_stage", vessel.control.setNextStageStream(connection.getExecutor()));
        streams.put("vessel.control.set_previous_stage", vessel.control.setPreviousStageStream(connection.getExecutor()));
        streams.put("vessel.control.set_relaunch", vessel.control.setRelaunchStream(connection.getExecutor()));
        streams.put("vessel.control.set_decouple", vessel.control.setDecoupleStream(connection.getExecutor()));
        streams.put("vessel.control.set_activate_next_stage", vessel.control.setActivateNextStageStream(connection.getExecutor()));
        streams.put("vessel.control.set_execute_next_stage", vessel.control.setExecuteNextStageStream(connection.getExecutor()));

        // Prepare rocket for launch
        vessel.getControl().setRCS(true);
        vessel.getControl().setSAS(true);
        vessel.getControl().setGear(true);
        vessel.getControl().setLights(true);
        vessel.getControl().setAntennas(true);
        vessel.getControl().setRadiators(true);
        vessel.getControl().setSolarPanels(true);
        vessel.getControl().setCover(true);
        vessel.getControl().setAbort(true);
        vessel.getControl().setDock(true);
        vessel.getControl().setArm(true);
        vessel.getControl().setDisarm(true);
        vessel.getControl().setEject(true);
        vessel.getControl().setRetract(true);
        vessel.getControl().setDeploy(true);
        vessel.getControl().setToggle(true);
        vessel.getControl().setEngage(true);
        vessel.getControl().setDisengage(true);
        vessel.getControl().setNextStage(true);
        vessel.getControl().setPreviousStage(true);
        vessel.getControl().setRelaunch(true);
        vessel.getControl().setUndock(true);
        vessel.getControl().setDecouple(true);
        vessel.getControl().setActivateNextStage(true);
        vessel.getControl().setExecuteNextStage(true);

        // Wait for streams to be updated
        connection.getExecutor().drain();
    }
}

```

```lua
local krpc = require('krpc')

-- Connect to kRPC server
local conn = krpc.connect(nil, 'localhost')
local sc = conn.services.space_center
print(string.format('Connected to kRPC Version %s', sc.version))

-- Get the active vessel
local vessel = sc.active_vessel
print(string.format('Vessel: %s', vessel.name))

-- Set up streams for flight telemetry
local streams = {}
streams['vessel.name'] = vessel:name_stream()
streams['vessel.type'] = vessel:type_stream()
streams['vessel.mass.total'] = vessel.mass:total_stream()
streams['vessel.orbit.apoapsis_altitude'] = vessel.orbit:apoapsis_altitude_stream()
streams['vessel.orbit.periapsis_altitude'] = vessel.orbit:periapsis_altitude_stream()
streams['vessel.flight.true_altitude'] = vessel:flight(vessel.surface_reference_frame):true_altitude_stream()
streams['vessel.flight.vertical_speed'] = vessel:flight(vessel.surface_reference_frame):vertical_speed_stream()
streams['vessel.flight.horizontal_speed'] = vessel:flight(vessel.surface_reference_frame):horizontal_speed_stream()
streams['vessel.flight.g_force'] = vessel:flight(vessel.surface_reference_frame):g_force_stream()
streams['vessel.control.throttle'] = vessel.control:throttle_stream()
streams['vessel.control.rcs'] = vessel.control:rcs_stream()
streams['vessel.control.sas'] = vessel.control:sas_stream()
streams['vessel.control.gear'] = vessel.control:gear_stream()
streams['vessel.control.brakes'] = vessel.control:brakes_stream()
streams['vessel.control.lights'] = vessel.control:lights_stream()
streams['vessel.control.antennas'] = vessel.control:antennas_stream()
streams['vessel.control.radiators'] = vessel.control:radiators_stream()
streams['vessel.control.solar_panels'] = vessel.control:solar_panels_stream()
streams['vessel.control.cover'] = vessel.control:cover_stream()
streams['vessel.control.abort'] = vessel.control:abort_stream()
streams['vessel.control.execute_next_stage'] = vessel.control:execute_next_stage_stream()
streams['vessel.control.next_stage'] = vessel.control:next_stage_stream()
streams['vessel.control.previous_stage'] = vessel.control:previous_stage_stream()
streams['vessel.control.relaunch'] = vessel.control:relaunch_stream()
streams['vessel.control.undock'] = vessel.control:undock_stream()
streams['vessel.control.dock'] = vessel.control:dock_stream()
streams['vessel.control.arm'] = vessel.control:arm_stream()
streams['vessel.control.disarm'] = vessel.control:disarm_stream()
streams['vessel.control.activate_next_stage'] = vessel.control:activate_next
```

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

### Basic kRPC Python 'Hello World' Script

Source: https://krpc.github.io/krpc/_sources/getting-started.rst

A simple Python script to connect to the kRPC server, get the active vessel, and print its name. Requires the kRPC server to be running in KSP.

```python
import krpc
conn = krpc.connect(name='Hello World')
vessel = conn.space_center.active_vessel
print(vessel.name)
```

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

### Set Dish Target and Get Signal Delay (Java)

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

This example demonstrates how to set the target of a dish on the active vessel and then retrieve the signal delay to that vessel using the RemoteTech API. It requires the kRPC library and the RemoteTech mod to be installed.

```java
import krpc.client.Connection;
import krpc.client.RPCException;
import krpc.client.services.krpc.schema.krpc.schema.RemoteTech.RemoteTechService;
import krpc.client.services.krpc.schema.krpc.schema.SpaceCenter.schema.SpaceCenterService;
import java.io.IOException;

public class RemoteTechExample {

    public static void main(String[] args) {
        Connection connection = null;
        try {
            connection = new Connection("localhost");
            SpaceCenterService spaceCenter = new SpaceCenterService(connection);
            RemoteTechService remoteTech = new RemoteTechService(connection);

            // Get the active vessel
            var vessel = spaceCenter.getActiveVessel();

            // Get the first antenna on the vessel
            var antenna = vessel.getAntennas().get(0);

            // Set the target to the active vessel
            remoteTech.setDishTarget(antenna, vessel);

            // Print the signal delay to the active vessel
            System.out.println("Signal delay to active vessel: " + remoteTech.getSignalDelay(vessel) + " seconds");

        } catch (IOException | RPCException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
```

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

### Set RemoteTech Target and Get Signal Delay (Python)

Source: https://krpc.github.io/krpc/_sources/python/api/remote-tech.rst

This example demonstrates setting the target of a dish on the active vessel using the RemoteTech API and then printing the signal delay to the active vessel. It requires the kRPC library and the RemoteTech mod to be installed.

```python
import krpc
import time

conn = krpc.connect(name='RemoteTech Example')

# Get the active vessel
active_vessel = conn.spacecenter.active_vessel

# Get the RemoteTech service
remote_tech = krpc.RemoteTechService(conn)

# Get the first antenna on the vessel
antenna = active_vessel.parts.antennae[0]

# Set the target to the KSC
target_body = conn.spacecenter.bodies.kerbin
target_station = target_body.reference_frame

remote_tech.set_target(antenna, target_station)

# Wait a moment for the target to be set
time.sleep(2)

# Get the signal delay to the active vessel
signal_delay = remote_tech.signal_delay(active_vessel.reference_frame)

print(f"Signal delay to active vessel: {signal_delay} seconds")

conn.close()
```

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

### Compile Cnano Client Example (Bash)

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

Provides the command to compile a Cnano client example program using GCC. This command links the C source file with the kRPC Cnano library.

```bash
gcc main.c -lkrpc_cnano

```

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

### InfernalRobotics API - Get Availability

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

Checks if Infernal Robotics is installed on the game client.

```APIDOC
## GET /infernalrobotics/available

### Description
Checks if Infernal Robotics is installed.

### Method
GET

### Endpoint
/infernalrobotics/available

### Parameters
#### Query Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **isAvailable** (boolean) - True if Infernal Robotics is installed, false otherwise.

#### Response Example
```json
{
  "isAvailable": true
}
```
```

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

### Install kRPC Client Dependencies (Bash)

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

Installs kRPC client dependencies, ASIO and protobuf, using apt-get on Ubuntu. ASIO is a header-only library, and protobuf is required for message serialization.

```bash
sudo apt-get install libasio-dev
```

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

### Get Wheels in Vessel (C)

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

Retrieves a list of all wheels installed on the vessel. This kRPC function is useful for controlling or querying wheeled components.

```C
krpc_error_t krpc_SpaceCenter_Parts_Wheels(krpc_connection_t connection, krpc_list_object_t *result);
```

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

### Connect and Prepare Rocket for Launch in C#

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

This C# code connects to the kRPC server, retrieves the active vessel, and sets up streams for essential flight telemetry like universal time, altitude, apoapsis, and solid fuel. It also performs pre-launch setup by disabling SAS and RCS and setting throttle to 1.

```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.ResourcesInDecoupleStage (stage: 2, 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!");

```

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

### Get Robotic Rotors in Vessel (C)

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

Retrieves a list of all robotic rotors installed on the vessel. This kRPC function enables interaction with rotary robotic components.

```C
krpc_error_t krpc_SpaceCenter_Parts_RoboticRotors(krpc_connection_t connection, krpc_list_object_t *result);
```

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

### Open kRPC Connection (C)

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

Demonstrates how to open a communication handle for kRPC client-server interaction. It shows different ways to initialize the connection based on build configurations (POSIX vs. Arduino) and argument types.

```c
krpc_connection_t conn;
krpc_error_t err;

// For POSIX systems (default)
err = krpc_open(&conn, "COM0"); // Or a serial port path like "/dev/ttyACM0"

// For Arduino, passing NULL for default baud rate (9600) and settings
// Ensure HardwareSerial object is correctly set up before calling krpc_open
// err = krpc_open(&conn, NULL);

// For Arduino, with custom configuration
// krpc_connection_config_t config;
// config.speed = 115200;
// config.config = SERIAL_5N1;
// err = krpc_open(&conn, &config);

```

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

### Get Reaction Wheels in Vessel (C)

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

Retrieves a list of all reaction wheels installed on the vessel. This kRPC function allows interaction with the vessel's attitude control components.

```C
krpc_error_t krpc_SpaceCenter_Parts_ReactionWheels(krpc_connection_t connection, krpc_list_object_t *result);
```

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

### Connect to kRPC Server on POSIX System (C)

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

Example C program to connect to a kRPC server on a POSIX system, query its version, and print it. It uses the `krpc_cnano.h` and `krpc_cnano/services/krpc.h` headers. Compilation requires linking with `-lkrpc_cnano`.

```c
#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);
}
```

```bash
gcc main.c -lkrpc_cnano
```

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

### Stream Class Methods for kRPC Client

Source: https://krpc.github.io/krpc/_sources/java/client.rst

Provides methods for managing data streams from the kRPC server. Includes starting, getting values, setting update rates, and handling callbacks. Streams can be started immediately or waited upon for the first update. Callbacks are invoked when stream values change.

```java
stream.start();
stream.startAndWait();
float rate = stream.getRate();
stream.setRate(10.0f);
T value = stream.get();
Object condition = stream.getCondition();
stream.waitForUpdate();
stream.waitForUpdateWithTimeout(5.0);
int tag = stream.addCallback(newValue -> System.out.println("New value: " + newValue));
stream.removeCallback(tag);
stream.remove();
```

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

### InfernalRobotics API Example (C++)

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

An example demonstrating how to use the InfernalRobotics API to interact with servos. It retrieves a servo group, lists servo names and positions, and then moves the servos.

```cpp
#include "krpc.hpp"
#include "krpc_test.hpp"
#include "InfernalRobotics.hpp"

#include <string>
#include <vector>

int main(int argc, char **argv) {
    krpc::Client client("localhost:50000");

    auto services = client.get_services();
    auto ir = InfernalRobotics(services);

    // Get the control group named "MyGroup"
    auto group = ir.get_servo_group("MyGroup");

    // Print out the names and positions of all servos in the group
    for (auto servo : group.get_servos()) {
        printf("Servo: %s, Position: %f\n", servo.get_name().c_str(), servo.get_position());
    }

    // Move all servos to the right for 1 second
    group.move_to_position(1.0, 1.0);
    std::this_thread::sleep_for(std::chrono::seconds(1));

    return 0;
}
```