CRSF for Arduino

https://github.com/zz-cat/crsfforarduino
Admin
CRSF for Arduino is an Arduino library that enables communication with ExpressLRS and TBS Crossfire...
Tokens:21,580
Snippets:129
Trust Score:7.8
License:AGPL-3.0
Update:6 months ago
Show doc for...
Tokens:
Raw
### Installation

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

Instructions for installing the CRSFforArduino library using the Arduino IDE Library Manager or PlatformIO.

```APIDOC
## Installation

### Arduino IDE Library Manager

```cpp
// Search for "CRSFforArduino" in Library Manager and install
// Then include in your sketch:
#include <CRSFforArduino.hpp>
```

### PlatformIO

```ini
; platformio.ini
[env:your_board]
lib_deps = zz-cat/CRSFforArduino
```
```

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

### Initialize CRSF for Arduino Protocol

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Demonstrates the usage of the begin method to start the CRSF protocol communication after instantiation.

```cpp
#include "CRSFforArduino.h"

/* Declare a null pointer to CRSF for Arduino. */
CRSFforArduino *crsf = nullptr;

void setup()
{
    /* Instantiate CRSF for Arduino. */
    crsf = new CRSFforArduino();

    /* Initialise CRSF for Arduino. */
    crsf->begin();
}

void loop()
{
    /* Your main code here... */
}
```

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

### Complete Telemetry Example

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

An example demonstrating how to combine various telemetry data transmissions within a single application.

```APIDOC
## Complete Telemetry Example

### Description
This example shows how to integrate multiple telemetry functions to send attitude, barometric altitude, battery, and GPS data.

### Method
N/A (This is a client-side implementation example)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```cpp
#include "CRSFforArduino.hpp"

CRSFforArduino crsf = CRSFforArduino(&Serial1);

// Attitude (decidegrees)
int16_t roll = -200, pitch = 150, yaw = 2758;

// Barometric altitude
uint16_t baroAltitude = 10;   // decimetres
int16_t verticalSpeed = 50;   // cm/s

// Battery
float batteryVoltage = 385.0F;  // mV * 100
float batteryCurrent = 150.0F;  // mA * 10
uint32_t batteryFuel = 700;
uint8_t batteryPercent = 50;

// GPS
float latitude = -41.182F, longitude = 174.949F;
float gpsAltitude = 10000.0F, speed = 500.0F, groundCourse = 275.8F;
uint8_t satellites = 12;

void setup()
{
    if (!crsf.begin())
    {
        while (1) { ; }
    }
}

void loop()
{
    uint32_t now = millis();

    // Attitude at 100 Hz
    static unsigned long lastAttitude = 0;
    if (now - lastAttitude >= 10)
    {
        lastAttitude = now;
        crsf.telemetryWriteAttitude(roll, pitch, yaw);
    }

    // Barometric altitude at 10 Hz
    static unsigned long lastBaro = 0;
    if (now - lastBaro >= 100)
    {
        lastBaro = now;
        crsf.telemetryWriteBaroAltitude(baroAltitude, verticalSpeed);
    }

    // Battery at 10 Hz
    static unsigned long lastBattery = 0;
    if (now - lastBattery >= 100)
    {
        lastBattery = now;
        crsf.telemetryWriteBattery(batteryVoltage, batteryCurrent, batteryFuel, batteryPercent);
    }

    // GPS at 1 Hz
    static unsigned long lastGps = 0;
    if (now - lastGps >= 1000)
    {
        lastGps = now;
        crsf.telemetryWriteGPS(latitude, longitude, gpsAltitude, speed, groundCourse, satellites);
    }

    crsf.update();
}
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

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

### Install CRSF for Arduino Library

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

Instructions for adding the library to Arduino IDE or PlatformIO projects.

```cpp
#include <CRSFforArduino.hpp>
```

```ini
[env:your_board]
lib_deps = zz-cat/CRSFforArduino
```

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

### Standard Arduino Object Lifecycle Management (with potential leak)

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Illustrates how an Arduino object might be managed within the loop function, including a simulated end-of-life process. This example highlights a common pattern that can lead to memory leaks if not handled carefully.

```cpp
void loop()
{
    static bool crsfEnded = false;

    if (crsfEnded == false)
    {
        static uint32_t start = millis();
        uint32_t now = millis();

        if (now - start <= 15000)
        {
            crsf.update();
        }
        else
        {
            crsf.end();
            crsfEnded = true;
        }
    }
}
```

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

### Complete Telemetry Implementation (Arduino)

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

A comprehensive example integrating multiple telemetry data types including attitude, barometric altitude, battery status, and GPS. This demonstrates how to combine different sensor readings for continuous transmission.

```cpp
#include "CRSFforArduino.hpp"

CRSFforArduino crsf = CRSFforArduino(&Serial1);

// Attitude (decidegrees)
int16_t roll = -200, pitch = 150, yaw = 2758;

// Barometric altitude
uint16_t baroAltitude = 10;   // decimetres
int16_t verticalSpeed = 50;   // cm/s

// Battery
float batteryVoltage = 385.0F;  // mV * 100
float batteryCurrent = 150.0F;  // mA * 10
uint32_t batteryFuel = 700;
uint8_t batteryPercent = 50;

// GPS
float latitude = -41.182F, longitude = 174.949F;
float gpsAltitude = 10000.0F, speed = 500.0F, groundCourse = 275.8F;
uint8_t satellites = 12;

void setup()
{
    if (!crsf.begin())
    {
        while (1) { ; }
    }
}

void loop()
{
    uint32_t now = millis();

    // Attitude at 100 Hz
    static unsigned long lastAttitude = 0;
    if (now - lastAttitude >= 10)
    {
        lastAttitude = now;
        crsf.telemetryWriteAttitude(roll, pitch, yaw);
    }

    // Barometric altitude at 10 Hz
    static unsigned long lastBaro = 0;
    if (now - lastBaro >= 100)
    {
        lastBaro = now;
        crsf.telemetryWriteBaroAltitude(baroAltitude, verticalSpeed);
    }

    // Battery at 10 Hz
    static unsigned long lastBattery = 0;
    if (now - lastBattery >= 100)
    {
        lastBattery = now;
        crsf.telemetryWriteBattery(batteryVoltage, batteryCurrent, batteryFuel, batteryPercent);
    }

    // GPS at 1 Hz
    static unsigned long lastGps = 0;
    if (now - lastGps >= 1000)
    {
        lastGps = now;
        crsf.telemetryWriteGPS(latitude, longitude, gpsAltitude, speed, groundCourse, satellites);
    }

    crsf.update();
}
```

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

### Initialize and Update CRSF Telemetry

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Demonstrates the standard lifecycle of a CRSF telemetry integration, including object instantiation in setup() and periodic sensor data updates in the loop() function.

```cpp
void setup() {
    crsf = new CRSFforArduino();
    if (crsf->begin() != false) {
        // Initialized successfully
    } else {
        crsf->end();
        delete crsf;
        crsf = nullptr;
    }
}

void loop() {
    if (crsf != nullptr) {
        pollSensors();
        crsf->update();
    }
}

void pollSensors() {
    static unsigned long lastSensorUpdate = millis();
    if (millis() - lastSensorUpdate >= 200) {
        lastSensorUpdate = millis();
        crsf->telemetryWriteAttitude(roll, pitch, yaw);
        crsf->telemetryWriteBaroAltitude(baroAltitude, verticalSpeed);
        crsf->telemetryWriteBattery(batteryVoltage, batteryCurrent, batteryFuel, batteryPercent);
        crsf->telemetryWriteGPS(latitude, longitude, altitude, speed, groundCourse, satellites);
    }
}
```

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

### Handle Link Connection and Disconnection Events with CRSFforArduino

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

This example shows how to register callback functions for link up and link down events using the CRSFforArduino library. These callbacks are essential for managing the state of the RF connection, such as indicating connection status with an LED or triggering failsafe procedures when the link is lost.

```cpp
void onLinkUp();
void onLinkDown();

void setup()
{
    // ... initialization code ...

    if (crsf->begin())
    {
        crsf->setLinkUpCallback(onLinkUp);
        crsf->setLinkDownCallback(onLinkDown);
    }
}

void onLinkUp()
{
    Serial.println("Link established with transmitter!");
    digitalWrite(LED_BUILTIN, HIGH);
}

void onLinkDown()
{
    Serial.println("Link lost! Entering failsafe mode.");
    digitalWrite(LED_BUILTIN, LOW);
}
```

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

### Implement Standard Flight Modes with CRSF for Arduino

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

This C++ code snippet demonstrates the implementation of standard flight modes using the CRSFforArduino library. It defines constants for different flight modes, initializes the CRSF library, sets up each flight mode with its corresponding channel and value ranges, and registers a callback function to handle flight mode changes. The `setup()` function initializes the library and configures flight modes, while the `loop()` function continuously updates the CRSF library. The `onFlightModeUpdate` function processes the received flight mode, updates telemetry, and prints the current mode to the Serial Monitor.

```cpp
#include "CRSFforArduino.hpp"

#define FLIGHT_MODE_ARM_CHANNEL 5
#define FLIGHT_MODE_ARM_MIN     1000
#define FLIGHT_MODE_ARM_MAX     1800

#define FLIGHT_MODE_ACRO_CHANNEL 6
#define FLIGHT_MODE_ACRO_MIN     750
#define FLIGHT_MODE_ACRO_MAX     1250

#define FLIGHT_MODE_ANGLE_CHANNEL 6
#define FLIGHT_MODE_ANGLE_MIN     1250
#define FLIGHT_MODE_ANGLE_MAX     1750

#define FLIGHT_MODE_HORIZON_CHANNEL 6
#define FLIGHT_MODE_HORIZON_MIN     1750
#define FLIGHT_MODE_HORIZON_MAX     2250

CRSFforArduino *crsf = nullptr;

/* Declare the onFlightModeUpdate callback function. */
void onFlightModeUpdate(serialReceiverLayer::flightModeId_t);

void setup()
{
    /* Initialise CRSF for Arduino. */
    crsf = new CRSFforArduino();
    if (crsf->begin() != false)
    {
        /* CRSF for Arduino initialised successfully.
        Now, the Flight Modes can be configured. */
        crsf->setFlightMode(serialReceiverLayer::FLIGHT_MODE_DISARMED, FLIGHT_MODE_ARM_CHANNEL, FLIGHT_MODE_ARM_MIN, FLIGHT_MODE_ARM_MAX);
        crsf->setFlightMode(serialReceiverLayer::FLIGHT_MODE_ACRO, FLIGHT_MODE_ACRO_CHANNEL, FLIGHT_MODE_ACRO_MIN, FLIGHT_MODE_ACRO_MAX);
        crsf->setFlightMode(serialReceiverLayer::FLIGHT_MODE_ANGLE, FLIGHT_MODE_ANGLE_CHANNEL, FLIGHT_MODE_ANGLE_MIN, FLIGHT_MODE_ANGLE_MAX);
        crsf->setFlightMode(serialReceiverLayer::FLIGHT_MODE_HORIZON, FLIGHT_MODE_HORIZON_CHANNEL, FLIGHT_MODE_HORIZON_MIN, FLIGHT_MODE_HORIZON_MAX);

        crsf->setFlightModeCallback(onFlightModeUpdate);
    }
    else
    {
        /* CRSF for Arduino failed to initialise. */
        crsf->end();
        delete crsf;
        crsf = nullptr;
    }
}

void loop()
{
    /* Guard CRSF for Arduino's API functions. */
    if (crsf != nullptr)
    {
        /* Run CRSF for Arduino's main function. */
        crsf->update();
    }
}

void onFlightModeUpdate(serialReceiverLayer::flightModeId_t flightMode)
{
    /* This is where you would normally write your own Flight Modes implementation.
    For the purposes of this example, the current Flight Mode is printed to the Serial Monitor. */

    /* Are we disarmed? */
    bool isDisarmed = true;
    if (flightMode != serialReceiverLayer::FLIGHT_MODE_DISARMED)
    {
        isDisarmed = false;
    }
    else if (isFailsafeActive)
    {
        isDisarmed = true;
    }

    /* Update the flight mode telemetry with the new value. */
    crsf->telemetryWriteFlightMode(flightMode, isDisarmed);

    /* Print the flight mode to the Serial Monitor, but only if the flight mode has changed. */
    static serialReceiverLayer::flightModeId_t lastFlightMode = serialReceiverLayer::FLIGHT_MODE_DISARMED;
    if (flightMode != lastFlightMode)
    {
        lastFlightMode = flightMode;

        Serial.print("[Sketch | INFO]: Flight Mode: ");
        switch (flightMode)
        {
            case serialReceiverLayer::FLIGHT_MODE_DISARMED:
                Serial.println("Disarmed");
                break;
            case serialReceiverLayer::FLIGHT_MODE_ACRO:
                Serial.println("Acro");
                break;
            case serialReceiverLayer::FLIGHT_MODE_WAIT:
                Serial.println("Wait for GPS Lock");
                break;
            case serialReceiverLayer::FLIGHT_MODE_FAILSAFE:
                Serial.println("Failsafe");
                break;
            case serialReceiverLayer::FLIGHT_MODE_GPS_RESCUE:
                Serial.println("GPS Rescue");
                break;
            case serialReceiverLayer::FLIGHT_MODE_PASSTHROUGH:
                Serial.println("Passthrough");
                break;
            case serialReceiverLayer::FLIGHT_MODE_ANGLE:
                Serial.println("Angle");
                break;
            case serialReceiverLayer::FLIGHT_MODE_HORIZON:
                Serial.println("Horizon");
                break;
            case serialReceiverLayer::FLIGHT_MODE_AIRMODE:
                Serial.println("Airmode");
                break;
            default:
                Serial.println("Unknown");
                break;
        }
    }
}
```

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

### Send Attitude Telemetry Data

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

Provides an example of sending roll, pitch, and yaw attitude data to the controller at a 100Hz frequency. Values are expected in decidegrees.

```cpp
#include "CRSFforArduino.hpp"

CRSFforArduino crsf = CRSFforArduino(&Serial1);

int16_t roll = -200;
int16_t pitch = 150;
int16_t yaw = 2758;

void setup()
{
    if (!crsf.begin()) { while (1) { ; } }
}

void loop()
{
    static unsigned long lastUpdate = 0;
    if (millis() - lastUpdate >= 10)
    {
        lastUpdate = millis();
        crsf.telemetryWriteAttitude(roll, pitch, yaw);
    }
    crsf.update();
}
```

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

### Implement CRSF Link Statistics Callback in Arduino

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

This C++ code snippet demonstrates how to initialize the CRSF for Arduino library, set a callback function for link statistics updates, and process the received statistics within the callback. It includes setup, loop, and callback functions for handling connection stability data.

```cpp
#include "CRSFforArduino.h"

CRSFforArduino *crsf = nullptr;

void onLinkStatisticsUpdate(serialReceiverLayer::link_statistics_t);

void setup()
{
    crsf = new CRSFforArduino();

    /* Initialise CRSF for Arduino. */
    if (crsf->begin() == true)
    {
        /* CRSF for Arduino initialised successfully.
        We can now register the Link Statistics event. */
        crsf->setLinkStatisticsCallback(onLinkStatisticsUpdate);
    }
    else
    {
        /* Clean up any resources,
        if initialisation fails. */
        crsf->end();
        delete crsf;
        crsf = nullptr;
    }
}

void loop()
{
    /* Guard CRSF for Arduino's API with a null check. */
    if (crsf != nullptr)
    {
        /* Call CRSF for Arduino's main function here. */
        crsf->update();
    }
}

void onLinkStatisticsUpdate(serialReceiverLayer::link_statistics_t linkStatistics)
{
    /* This is your Link Statistics Event Callback.
    By using the linkStatistics parameter that's passed in,
    you have access to the following:
    - linkStatistics.rssi
    - linkStatistics.lqi
    - linkStatistics.snr
    - linkStatistics.tx_power

    For the purposes of this example, these values are simply
    printed to the Serial Monitor at a rate of 5 Hz. */

    static unsigned long lastPrint = 0;
    if (millis() - lastPrint >= 200)
    {
        lastPrint = millis();
        Serial.print("Link Statistics: ");
        Serial.print("RSSI: ");
        Serial.print(linkStatistics.rssi);
        Serial.print(", Link Quality: ");
        Serial.print(linkStatistics.lqi);
        Serial.print(", Signal-to-Noise Ratio: ");
        Serial.print(linkStatistics.snr);
        Serial.print(", Transmitter Power: ");
        Serial.println(linkStatistics.tx_power);
    }
}
```

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

### Method: begin()

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Initializes the serial communication and the CRSF protocol stack.

```APIDOC
## Method: begin()

### Description
Starts the CRSF communication interface. Configures the baud rate and internal protocol settings.

### Method
void begin(uint32_t baud_rate)

### Parameters
#### Query Parameters
- **baud_rate** (uint32_t) - Optional - The baud rate for serial communication. Defaults to the standard Crossfire protocol baud rate if not specified.

### Response
#### Success Response (bool)
- **Returns** (bool) - Returns true if initialization was successful, false otherwise.

### Request Example
if (crsf->begin()) {
    // Initialization successful
}
```

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

### Basic Initialization

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

Demonstrates how to initialize the CRSF for Arduino library with proper resource management, including error handling.

```APIDOC
## Basic Initialization

Initialize CRSF for Arduino with proper resource management using dynamic memory allocation to prevent memory leaks on embedded systems.

```cpp
#include "CRSFforArduino.hpp"

CRSFforArduino *crsf = nullptr;

void setup()
{
    Serial.begin(115200);
    while (!Serial) { ; }

    // Allocate and initialize CRSF for Arduino
    crsf = new CRSFforArduino();

    if (!crsf->begin())
    {
        // Clean up resources if initialization fails
        crsf->end();
        delete crsf;
        crsf = nullptr;

        Serial.println("CRSF for Arduino initialization failed!");
        while (1) { delay(10); }
    }

    Serial.println("CRSF for Arduino initialized successfully");
}

void loop()
{
    // Guard API calls with null check
    if (crsf != nullptr)
    {
        // Must be called frequently (at least every 4ms)
        crsf->update();
    }
}
```
```

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

### Standard Arduino Object Initialization

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Demonstrates the typical Arduino approach to object initialization and usage, where an object is globally declared and immediately initialized. This method is contrasted with a more resource-conscious approach.

```cpp
#include "CRSFforArduino.h"

CRSFforArduino crsf = CRSFforArduino();

void setup()
{
    crsf.begin();
}

void loop()
{
    crsf.update();
}
```

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

### Initialize CRSF for Arduino Instance

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

Demonstrates the standard lifecycle of the CRSF library, including dynamic allocation, initialization, and the required update loop.

```cpp
#include "CRSFforArduino.hpp"

CRSFforArduino *crsf = nullptr;

void setup() {
    Serial.begin(115200);
    crsf = new CRSFforArduino();
    if (!crsf->begin()) {
        crsf->end();
        delete crsf;
        crsf = nullptr;
    }
}

void loop() {
    if (crsf != nullptr) {
        crsf->update();
    }
}
```

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

### Configure CRSF Constructor Options

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

Shows how to instantiate the CRSF object using default settings, custom serial ports, or specific pin mappings for ESP32.

```cpp
// Default constructor
CRSFforArduino *crsf = new CRSFforArduino();

// Custom serial port
CRSFforArduino *crsf = new CRSFforArduino(&Serial2);

// Custom serial port with pins (ESP32)
#define MY_UART_RX_PIN 2
#define MY_UART_TX_PIN 3
CRSFforArduino *crsf = new CRSFforArduino(&Serial1, MY_UART_RX_PIN, MY_UART_TX_PIN);
```

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

### Instantiate CRSF for Arduino with Default Serial

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Demonstrates the standard way to create an instance of the CRSF for Arduino library using default hardware serial settings.

```cpp
#include "CRSFforArduino.h"

/* Declare a null pointer to CRSF for Arduino. */
CRSFforArduino *crsf = nullptr;

void setup()
{
    /* Instantiate CRSF for Arduino. */
    crsf = new CRSFforArduino();
}

void loop()
{
    /* Your main code here... */
}
```

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

### Configure Standard Flight Modes with CRSFforArduino

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

Demonstrates how to initialize the CRSF library and map standard Betaflight-style flight modes to specific RC channels with defined PWM ranges. It includes a callback function to handle mode changes and report status via telemetry.

```cpp
#include "CRSFforArduino.hpp"

#define ARM_CHANNEL     5
#define ARM_MIN         1000
#define ARM_MAX         1800

#define MODE_CHANNEL    8
#define ACRO_MIN        900
#define ACRO_MAX        1300
#define ANGLE_MIN       1300
#define ANGLE_MAX       1700
#define HORIZON_MIN     1700
#define HORIZON_MAX     2100

CRSFforArduino crsf = CRSFforArduino(&Serial1);

void onFlightModeUpdate(serialReceiverLayer::flightModeId_t flightMode);

void setup()
{
    Serial.begin(115200);
    if (!crsf.begin())
    {
        Serial.println("CRSF initialization failed!");
        while (1) { ; }
    }

    crsf.setFlightMode(serialReceiverLayer::FLIGHT_MODE_DISARMED, ARM_CHANNEL, ARM_MIN, ARM_MAX);
    crsf.setFlightMode(serialReceiverLayer::FLIGHT_MODE_ACRO, MODE_CHANNEL, ACRO_MIN, ACRO_MAX);
    crsf.setFlightMode(serialReceiverLayer::FLIGHT_MODE_ANGLE, MODE_CHANNEL, ANGLE_MIN, ANGLE_MAX);
    crsf.setFlightMode(serialReceiverLayer::FLIGHT_MODE_HORIZON, MODE_CHANNEL, HORIZON_MIN, HORIZON_MAX);

    crsf.setFlightModeCallback(onFlightModeUpdate);
}

void loop()
{
    crsf.update();
}
```

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

### Initialize and Manage CRSFforArduino Resources

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

This C++ snippet demonstrates the lifecycle management of the CRSFforArduino library. It shows how to dynamically allocate and initialize the library using `new CRSFforArduino()`, handle initialization failures, and properly clean up resources using `end()` and `delete` to prevent memory leaks. The `loop()` function continuously calls `update()` for data processing and includes logic to stop the library and free resources after a specified duration.

```cpp
#include "CRSFforArduino.hpp"

CRSFforArduino *crsf = nullptr;

void setup()
{
    crsf = new CRSFforArduino();

    if (crsf->begin() != true)
    {
        // Cleanup on initialization failure
        crsf->end();
        delete crsf;
        crsf = nullptr;
    }
}

void loop()
{
    if (crsf != nullptr)
    {
        static uint32_t startTime = millis();

        // Run for 60 seconds then cleanup
        if (millis() - startTime <= 60000)
        {
            crsf->update();
        }
        else
        {
            // Proper cleanup sequence
            crsf->end();      // Free hardware resources
            delete crsf;      // Free memory
            crsf = nullptr;   // Prevent dangling pointer

            Serial.println("CRSF for Arduino stopped and resources freed");
        }
    }
}

```

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

### Instantiate CRSF for Arduino with Custom ESP32 Pins

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Shows how to initialize the library on an ESP32 target by specifying custom RX and TX pins for the serial communication.

```cpp
#include "CRSFforArduino.h"

/* Define your custom UART pinouts here. */
#define MY_UART_RX_PIN 2
#define MY_UART_TX_PIN 3

/* Declare a null pointer to CRSF for Arduino. */
CRSFforArduino *crsf = nullptr;

void setup()
{
    /* Instantiate CRSF for Arduino with your custom pins. */
    crsf = new CRSFforArduino(&Serial1, MY_UART_RX_PIN, MY_UART_TX_PIN);
}

void loop()
{
    /* Your main code here... */
}
```

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

### Constructor Options

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

Explains the different ways to construct the CRSFforArduino object, including default, custom serial port, and custom pins for ESP32.

```APIDOC
## Constructor Options

### Default Constructor

Uses `Serial1` with default pins (0 for RX, 1 for TX).

```cpp
CRSFforArduino *crsf = new CRSFforArduino();
```

### Custom Serial Port

Specify a custom HardwareSerial instance for SAMD21/51 targets.

```cpp
CRSFforArduino *crsf = new CRSFforArduino(&Serial2);
```

### Custom Serial Port with Pins (ESP32)

For ESP32 targets, specify both the serial port and custom pin assignments.

```cpp
#define MY_UART_RX_PIN 2
#define MY_UART_TX_PIN 3

CRSFforArduino *crsf = new CRSFforArduino(&Serial1, MY_UART_RX_PIN, MY_UART_TX_PIN);
```
```

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

### Implement Telemetry in Arduino Firmware

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

This snippet demonstrates the initialization of telemetry variables and the structure for integrating sensor data into the CRSF for Arduino library. Users must replace the placeholder values with actual data from their hardware sensor drivers.

```cpp
#include "CRSFforArduino.hpp"

CRSFforArduino *crsf = nullptr;

/* Initialise the attitude telemetry with default values. */
int16_t roll = 0;  // Roll is in decided degrees (eg -200 = -20.0 degrees).
int16_t pitch = 0; // Pitch is in decided degrees (eg 150 = 15.0 degrees).
uint16_t yaw = 0;  // Yaw is in decided degrees (eg 2758 = 275.8 degrees);
```

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

### CRSF for Arduino Dynamic Resource Allocation and Management

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Demonstrates the proper way to dynamically allocate and deallocate resources for CRSF for Arduino using `new` and `delete`. This includes initializing the object, handling potential allocation failures, and freeing resources when finished to prevent memory leaks.

```cpp
void setup()
{
    crsf = new CRSFforArduino();

    if (crsf->begin() == true)
    {
    }
    else
    {
        crsf->end();
        delete crsf;
        crsf = nullptr;
    }
}

void loop()
{
    if (crsf != nullptr)
    {
        static uint32_t start = millis();
        uint32_t now = millis();

        if (now - start <= 15000)
        {
            crsf->update();
        }
        else
        {
            crsf->end();
            delete crsf;
            crsf = nullptr;
        }
    }
}
```

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

### Configuration API Reference

Source: https://github.com/zz-cat/crsfforarduino/wiki/Configuration-and-Functionality

Overview of the pre-processor configuration flags for the CRSF for Arduino library.

```APIDOC
## Configuration API

### Description
The CRSF for Arduino library uses a configuration header file `CFA_Config.hpp` to enable or disable specific features. These are set via pre-processor defines.

### Parameters
#### Link Statistics
- **CRSF_LINK_STATISTICS_ENABLED** (int) - Required - Default 1. Enables Link Statistics API and fail-safe detection.

#### RC Channels
- **CRSF_RC_ENABLED** (int) - Required - Default 1. Enables RC Channels API.
- **CRSF_RC_MAX_CHANNELS** (int) - Required - Default 16. Max channels supported.
- **CRSF_RC_CHANNEL_MIN/MAX/CENTER** (int) - Required - Raw values for channel calibration.

#### Flight Modes
- **CRSF_FLIGHTMODES_ENABLED** (int) - Required - Default 0. Enables Flight Modes API.
- **CRSF_CUSTOM_FLIGHT_MODES_ENABLED** (int) - Optional - Enables custom flight mode support.

#### Telemetry
- **CRSF_TELEMETRY_ENABLED** (int) - Required - Default 1. Enables Telemetry API.
- **CRSF_TELEMETRY_ATTITUDE_ENABLED** (int) - Optional - Enables attitude telemetry.
- **CRSF_TELEMETRY_BATTERY_ENABLED** (int) - Optional - Enables battery telemetry.

### Request Example
// In CFA_Config.hpp
#define CRSF_RC_ENABLED 1
#define CRSF_TELEMETRY_ENABLED 1
```

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

### CRSF for Arduino Null Pointer Initialization

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Shows the recommended method for initializing CRSF for Arduino by declaring it as a null pointer. This defers resource allocation until explicitly requested, preventing immediate memory usage.

```cpp
#include "CRSFforArduino.h"

CRSFforArduino *crsf = nullptr;
```

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

### Configure CRSFforArduino Library Options

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

This snippet shows how to configure various features of the CRSFforArduino library using preprocessor defines in `CFA_Config.hpp`. Options include RC channel settings, link statistics, failsafe thresholds, flight modes, telemetry, and debug output. Set defines to 1 to enable and 0 to disable features.

```cpp
// CFA_Config.hpp configuration options

// RC Channels Configuration
#define CRSF_RC_ENABLED                    1   // Enable/disable RC API
#define CRSF_RC_MAX_CHANNELS               16  // Max channels (up to 16)
#define CRSF_RC_CHANNEL_MIN                172 // Raw minimum value
#define CRSF_RC_CHANNEL_MAX                1811// Raw maximum value
#define CRSF_RC_CHANNEL_CENTER             992 // Raw center value
#define CRSF_RC_INITIALISE_CHANNELS        1   // Init channels to center
#define CRSF_RC_INITIALISE_ARMCHANNEL      1   // Init Aux1 to minimum (safe)
#define CRSF_RC_INITIALISE_THROTTLECHANNEL 1   // Init throttle to minimum

// Link Statistics
#define CRSF_LINK_STATISTICS_ENABLED       1   // Enable link stats (required for failsafe)

// Failsafe Thresholds
#define CRSF_FAILSAFE_LQI_THRESHOLD        80  // Minimum LQI percentage
#define CRSF_FAILSAFE_RSSI_THRESHOLD       105 // Minimum RSSI (match Lua script)

// Flight Modes Configuration
#define CRSF_FLIGHTMODES_ENABLED           0   // Enable flight modes API
#define CRSF_CUSTOM_FLIGHT_MODES_ENABLED   0   // Enable custom flight mode names

// Telemetry Configuration
#define CRSF_TELEMETRY_ENABLED             1   // Master telemetry enable
#define CRSF_TELEMETRY_ATTITUDE_ENABLED    1   // Attitude telemetry
#define CRSF_TELEMETRY_BAROALTITUDE_ENABLED 1  // Barometric altitude
#define CRSF_TELEMETRY_BATTERY_ENABLED     1   // Battery telemetry
#define CRSF_TELEMETRY_FLIGHTMODE_ENABLED  0   // Flight mode telemetry
#define CRSF_TELEMETRY_GPS_ENABLED         1   // GPS telemetry

// Debug Configuration
#define CRSF_DEBUG_ENABLED                 0   // Enable debug output
#define CRSF_DEBUG_SERIAL_PORT             Serial // Debug serial port

```

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

### Read Individual RC Channels and Convert to Microseconds with CRSFforArduino

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

Shows how to read individual RC channel values using `getChannel()` and convert these raw values to microseconds using `rcToUs()`. This is useful for monitoring specific channels like throttle and arm switches.

```cpp
void loop()
{
    if (crsf != nullptr)
    {
        crsf->update();

        static unsigned long lastRead = 0;
        if (millis() - lastRead >= 100)
        {
            lastRead = millis();

            // Read channels 1-4 (Aileron, Elevator, Throttle, Rudder)
            uint16_t aileron  = crsf->rcToUs(crsf->getChannel(1));  // 988-2012 us
            uint16_t elevator = crsf->rcToUs(crsf->getChannel(2));
            uint16_t throttle = crsf->rcToUs(crsf->getChannel(3));
            uint16_t rudder   = crsf->rcToUs(crsf->getChannel(4));

            // Read auxiliary channels
            uint16_t armSwitch = crsf->rcToUs(crsf->getChannel(5));  // Aux1

            Serial.print("Throttle: ");
            Serial.print(throttle);
            Serial.print(" us, Arm: ");
            Serial.println(armSwitch > 1500 ? "ARMED" : "DISARMED");
        }
    }
}

// Expected output:
// Throttle: 1000 us, Arm: DISARMED
// Throttle: 1250 us, Arm: ARMED
```

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

### Implementing the Main Update Loop

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Shows the implementation of the update() function, which is required to process events. It should be called within the main loop at a frequency of at least 250Hz (every 4ms).

```cpp
#include "CRSFforArduino.h"

CRSFforArduino *crsf = nullptr;

void setup() {
    crsf = new CRSFforArduino();
    if (crsf->begin() != true) {
        crsf->end();
        delete crsf;
        crsf = nullptr;
    }
}

void loop() {
    if (crsf != nullptr) {
        crsf->update();
    }
}
```

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

### Constructor: CRSFforArduino

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

Creates an instance of the CRSF for Arduino library. You must instantiate the object before calling any other API functions.

```APIDOC
## Constructor: CRSFforArduino()

### Description
Initializes the CRSF for Arduino instance. Automatically selects the appropriate HardwareSerial port based on the target architecture (e.g., Serial1, Serial2, or Serial3).

### Method
Constructor

### Parameters
#### Path Parameters
- **serialPort** (HardwareSerial*) - Optional - Custom serial port instance for communication.
- **RxPin** (int) - Optional - UART Rx pin number (ESP32 specific).
- **TxPin** (int) - Optional - UART Tx pin number (ESP32 specific).

### Request Example
// Default instantiation
CRSFforArduino *crsf = new CRSFforArduino();

// Custom pins instantiation (ESP32)
CRSFforArduino *crsf = new CRSFforArduino(&Serial1, 2, 3);
```

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

### Register RC Channels Callback with CRSFforArduino

Source: https://context7.com/zz-cat/crsfforarduino/llms.txt

Demonstrates how to register a callback function to receive RC channel data. The callback handles incoming raw 11-bit channel values and includes logic for failsafe detection and processing. It converts raw values to microseconds for easier use.

```cpp
#include "CRSFforArduino.hpp"

CRSFforArduino *crsf = nullptr;
bool isFailsafeActive = false;

const char *rcChannelNames[] = {"A", "E", "T", "R", "Aux1", "Aux2", "Aux3", "Aux4",
                                 "Aux5", "Aux6", "Aux7", "Aux8", "Aux9", "Aux10", "Aux11", "Aux12"};

void onReceiveRcChannels(serialReceiverLayer::rcChannels_t *rcChannels);

void setup()
{
    Serial.begin(115200);
    while (!Serial) { ; }

    crsf = new CRSFforArduino();

    if (crsf->begin())
    {
        // Register the RC channels callback
        crsf->setRcChannelsCallback(onReceiveRcChannels);
        Serial.println("Ready");
    }
    else
    {
        crsf->end();
        delete crsf;
        crsf = nullptr;
    }
}

void loop()
{
    if (crsf != nullptr)
    {
        crsf->update();
    }
}

void onReceiveRcChannels(serialReceiverLayer::rcChannels_t *rcChannels)
{
    // Check failsafe status
    if (rcChannels->failsafe)
    {
        if (!isFailsafeActive)
        {
            isFailsafeActive = true;
            Serial.println("Failsafe detected!");

            // Center all channels except Aux1 (arm channel)
            for (int i = 0; i < 16; i++)
            {
                if (i != 4) rcChannels->value[i] = 992;  // Center
            }
            rcChannels->value[4] = 191;  // Disarm position
        }
        return;
    }

    if (isFailsafeActive)
    {
        isFailsafeActive = false;
        Serial.println("Failsafe cleared");
    }

    // Print RC channels at 10 Hz
    static unsigned long lastPrint = 0;
    if (millis() - lastPrint >= 100)
    {
        lastPrint = millis();

        Serial.print("RC Channels <");
        for (int i = 0; i < 8; i++)
        {
            Serial.print(rcChannelNames[i]);
            Serial.print(": ");
            Serial.print(crsf->rcToUs(rcChannels->value[i]));  // Convert to microseconds
            if (i < 7) Serial.print(", ");
        }
        Serial.println(">");
    }
}

// Expected output:
// Ready
// RC Channels <A: 1500, E: 1500, T: 1000, R: 1500, Aux1: 1000, Aux2: 1500, Aux3: 1500, Aux4: 1500>
```

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

### Set and Handle RC Channels Callback in C++

Source: https://github.com/zz-cat/crsfforarduino/wiki/API-Reference

This snippet demonstrates how to set a callback function to receive RC channel data and handle failsafe events. It includes initialization, event registration, and data processing logic. The callback receives raw RC channel values and a failsafe flag, converting raw values to microseconds for output.

```cpp
#include "CRSFforArduino.h"

CRSFforArduino *crsf = nullptr;

/* A flag to hold the fail-safe status. */
bool isFailsafeActive = false;

/* RC Channels data. */
int rcChannelCount = 8;
const char *rcChannelNames[] = {
    "A",
    "E",
    "T",
    "R",
    "Aux1",
    "Aux2",
    "Aux3",
    "Aux4",

    "Aux5",
    "Aux6",
    "Aux7",
    "Aux8",
    "Aux9",
    "Aux10",
    "Aux11",
    "Aux12"};

/* RC Channels Event Callback. */
void onReceiveRcChannels(serialReceiverLayer::rcChannels_t *rcData);

void setup()
{
    crsf = new CRSFforArduino();

    /* Initialise CRSF for Arduino. */
    if (crsf->begin() == true)
    {
        /* CRSF for Arduino initialised successfully.
        We can now register the RC Channels event. */
        crsf->setRcChannelsCallback(onReceiveRcChannels);

        /* Constrain the RC Channels Count to the maximum number
        of channels that are specified by The Crossfire Protocol.*/
        rcChannelCount = rcChannelCount > crsfProtocol::RC_CHANNEL_COUNT ? crsfProtocol::RC_CHANNEL_COUNT : rcChannelCount;
    }
    else
    {
        /* Clean up any resources,
        if initialisation fails. */
        crsf->end();
        delete crsf;
        crsf = nullptr;
    }
}

void loop()
{
    /* Guard CRSF for Arduino's API with a null check. */
    if (crsf != nullptr)
    {
        /* Call CRSF for Arduino's main function here. */
        crsf->update();
    }
}

void onReceiveRcChannels(serialReceiverLayer::rcChannels_t *rcData)
{
    /* This is your RC Channels Event Callback.
    Here, you have access to all 16 11-bit channels,
    plus an additional "failsafe" flag that tells you whether-or-not
    your receiver is connected to your controller's transmitter module.

    Using the rcData parameter that was passed in, 
    you have access to the following:

    - failsafe - A boolean flag indicating the "Fail-safe" status.
    - value[16] - An array consisting of all 16 received RC channels.
      NB: RC Channels are RAW values and are NOT in "microseconds" units.

    For the purposes of this example, the fail-safe flag is used to centre
    all channels except for Channel 5 (AKA Aux1). Aux1 is set to the
    "Disarmed" position.
    The RC Channels themselves are all converted to "microseconds" for
    visualisation purposes, and printed to the Serial Monitor at a rate
    of 100 Hz. */

    if (rcData->failsafe)
    {
        if (!isFailsafeActive)
        {
            isFailsafeActive = true;

            /* Centre all RC Channels, except for Channel 5 (Aux1). */
            for (int i = 0; i < rcChannelCount; i++)
            {
                if (i != 4)
                {
                    rcData->value[i] = 992;
                }
            }

            /* Set Channel 5 (Aux1) to its minimum value. */
            rcData->value[4] = 191;

            Serial.println("[Sketch | WARN]: Failsafe detected.");
        }
    }
    else
    {
        /* Set the failsafe status to false. */
        if (isFailsafeActive)
        {
            isFailsafeActive = false;
            Serial.println("[Sketch | INFO]: Failsafe cleared.");
        }
    }

    /* Here is where you may write your RC channels implementation.
    For this example, RC Channels are simply sent to the Serial Monitor. */
    static uint32_t lastPrint = millis();

    if (millis() - lastPrint >= 10)
    {
        lastPrint = millis();

        Serial.print("[Sketch | INFO]: RC Channels: <");
        for (int i = 0; i < rcChannelCount; i++)
        {
            Serial.print(rcChannelNames[i]);
            Serial.print(": ");
            Serial.print(crsf->rcToUs(rcData->value[i]));

            if (i < (rcChannelCount - 1))
            {
                Serial.print(", ");
            }
        }
        Serial.println(">");
    }
}
```
Tokens:
Raw