ardupilot/libraries/AP_PiccoloCAN/piccolo_protocol/ESCPackets.h

// ESCPackets.h was generated by ProtoGen version 3.5.c

/*
 * This file is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This file is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Oliver Walters / Currawong Engineering Pty Ltd
 */

#ifndef _ESCPACKETS_H
#define _ESCPACKETS_H

// Language target is C, C++ compilers: don't mangle us
#ifdef __cplusplus
extern "C" {
#endif

/*!
 * \file
 */

#include <stdint.h>
#include <stdbool.h>
#include "ESCVelocityProtocol.h"
#include "ESCDefines.h"

typedef struct
{
    unsigned reserved : 2;
    unsigned polarity : 3;
}ESC_HallSensorPattern_t;

//! return the minimum encoded length for the ESC_HallSensorPattern_t structure
#define getMinLengthOfESC_HallSensorPattern_t() (1)

//! return the maximum encoded length for the ESC_HallSensorPattern_t structure
#define getMaxLengthOfESC_HallSensorPattern_t() (1)

//! Encode a ESC_HallSensorPattern_t into a byte array
void encodeESC_HallSensorPattern_t(uint8_t* data, int* bytecount, const ESC_HallSensorPattern_t* user);

//! Decode a ESC_HallSensorPattern_t from a byte array
int decodeESC_HallSensorPattern_t(const uint8_t* data, int* bytecount, ESC_HallSensorPattern_t* user);

/*!
 * RPM control loop settings
 */
typedef struct
{
    ESC_ControlLoopCommon_t pid;          //!< Core control loop settings
    uint16_t                rpmRateLimit; //!< RPM setpoint rate limit
    float                   rpmFilter;    //!< Corner frequency for RPM measurement LPF
}ESC_RPMControlLoopSettings_t;

//! Create the ESC_RPMControlLoopSettings packet
void encodeESC_RPMControlLoopSettingsPacketStructure(void* pkt, const ESC_RPMControlLoopSettings_t* user);

//! Decode the ESC_RPMControlLoopSettings packet
int decodeESC_RPMControlLoopSettingsPacketStructure(const void* pkt, ESC_RPMControlLoopSettings_t* user);

//! Encode a ESC_RPMControlLoopSettings_t into a byte array
void encodeESC_RPMControlLoopSettings_t(uint8_t* data, int* bytecount, const ESC_RPMControlLoopSettings_t* user);

//! Decode a ESC_RPMControlLoopSettings_t from a byte array
int decodeESC_RPMControlLoopSettings_t(const uint8_t* data, int* bytecount, ESC_RPMControlLoopSettings_t* user);

//! return the packet ID for the ESC_RPMControlLoopSettings packet
#define getESC_RPMControlLoopSettingsPacketID() (PKT_ESC_RPM_LOOP_SETTINGS)

//! return the minimum encoded length for the ESC_RPMControlLoopSettings packet
#define getESC_RPMControlLoopSettingsMinDataLength() (8)

//! return the maximum encoded length for the ESC_RPMControlLoopSettings packet
#define getESC_RPMControlLoopSettingsMaxDataLength() (15)

/*!
 * General ESC configuration parameters
 */
typedef struct
{
    bool    swInhibit;         //!< 1 = ESC is inhibited (disabled) on startup
    bool    piccoloCommands;   //!< 1 = ESC will respond to PICCOLO autopilot commands
    bool    broadcastCommands; //!< 1 = ESC will accept broadcast command messages
    bool    enablePwmInput;    //!< 1 = Digital PWM input is enabled
    uint8_t motorTempSensor;   //!< External motor temperature sensor configuration
    uint8_t keepalive;         //!< ESC keepalive timeout - If this is non-zero, the ESC will automatically revert to *STANDBY* mode if it does not receive a valid command for the alloted period
    uint8_t disableLED;        //!< 1 = Disable LED
    uint8_t canBitRate;        //!< CAN bit (baud) rate
    uint8_t canProtocol;       //!< Protocol to communicate over CAN
    bool    motorBraking;      //!< Enable motor brake strength (applied when motor is off)
    uint8_t swInhibitDelay;    //!< Delay between hardware inhibit and software inhibit events
    uint8_t motorBeepMode;     //!< Sets the motor beep mode for the ESC
    uint8_t motorBeepVolume;   //!< Motor beep volume
}ESC_Config_t;

//! Create the ESC_Config packet
void encodeESC_ConfigPacketStructure(void* pkt, const ESC_Config_t* user);

//! Decode the ESC_Config packet
int decodeESC_ConfigPacketStructure(const void* pkt, ESC_Config_t* user);

//! Create the ESC_Config packet from parameters
void encodeESC_ConfigPacket(void* pkt, bool swInhibit, bool piccoloCommands, bool broadcastCommands, bool enablePwmInput, uint8_t motorTempSensor, uint8_t keepalive, uint8_t disableLED, uint8_t canBitRate, uint8_t canProtocol, bool motorBraking, uint8_t swInhibitDelay, uint8_t motorBeepMode, uint8_t motorBeepVolume);

//! Decode the ESC_Config packet to parameters
int decodeESC_ConfigPacket(const void* pkt, bool* swInhibit, bool* piccoloCommands, bool* broadcastCommands, bool* enablePwmInput, uint8_t* motorTempSensor, uint8_t* keepalive, uint8_t* disableLED, uint8_t* canBitRate, uint8_t* canProtocol, bool* motorBraking, uint8_t* swInhibitDelay, uint8_t* motorBeepMode, uint8_t* motorBeepVolume);

//! Encode a ESC_Config_t into a byte array
void encodeESC_Config_t(uint8_t* data, int* bytecount, const ESC_Config_t* user);

//! Decode a ESC_Config_t from a byte array
int decodeESC_Config_t(const uint8_t* data, int* bytecount, ESC_Config_t* user);

//! return the packet ID for the ESC_Config packet
#define getESC_ConfigPacketID() (PKT_ESC_CONFIG)

//! return the minimum encoded length for the ESC_Config packet
#define getESC_ConfigMinDataLength() (8)

//! return the maximum encoded length for the ESC_Config packet
#define getESC_ConfigMaxDataLength() (8)

/*!
 * Telemetry settings (storage class)
 */
typedef struct
{
    uint8_t                period;  //!< Telemetry period code (maps indirectly to a telemetry period value)
    uint8_t                silence; //!< Telemetry silence period (delay after RESET before telemetry data is sent)
    ESC_TelemetryPackets_t packets; //!< Bitfield describing which telemetry packets are enabled
}ESC_TelemetryConfig_t;

//! Create the ESC_TelemetryConfig packet
void encodeESC_TelemetryConfigPacketStructure(void* pkt, const ESC_TelemetryConfig_t* user);

//! Decode the ESC_TelemetryConfig packet
int decodeESC_TelemetryConfigPacketStructure(const void* pkt, ESC_TelemetryConfig_t* user);

//! Create the ESC_TelemetryConfig packet from parameters
void encodeESC_TelemetryConfigPacket(void* pkt, uint8_t period, uint8_t silence, const ESC_TelemetryPackets_t* packets);

//! Decode the ESC_TelemetryConfig packet to parameters
int decodeESC_TelemetryConfigPacket(const void* pkt, uint8_t* period, uint8_t* silence, ESC_TelemetryPackets_t* packets);

//! Encode a ESC_TelemetryConfig_t into a byte array
void encodeESC_TelemetryConfig_t(uint8_t* data, int* bytecount, const ESC_TelemetryConfig_t* user);

//! Decode a ESC_TelemetryConfig_t from a byte array
int decodeESC_TelemetryConfig_t(const uint8_t* data, int* bytecount, ESC_TelemetryConfig_t* user);

//! return the packet ID for the ESC_TelemetryConfig packet
#define getESC_TelemetryConfigPacketID() (PKT_ESC_TELEMETRY_SETTINGS)

//! return the minimum encoded length for the ESC_TelemetryConfig packet
#define getESC_TelemetryConfigMinDataLength() (3)

//! return the maximum encoded length for the ESC_TelemetryConfig packet
#define getESC_TelemetryConfigMaxDataLength() (3)

/*!
 * This packet can be used to simultaneously command multiple ESCs which have
 * sequential CAN ID values. This packet must be sent as a broadcast packet
 * (address = 0xFF) such that all ESCs can receive it. These commands can be
 * sent to groups of ESCs with ID values up to 64, using different
 * ESC_SETPOINT_x packet ID values.
 */
typedef struct
{
    uint16_t pwmValueA; //!< The PWM (pulse width) command for ESC with CAN ID [PKT_ID + 1]
    uint16_t pwmValueB; //!< The PWM (pulse width) command for ESC with CAN ID [PKT_ID + 2]
    uint16_t pwmValueC; //!< The PWM (pulse width) command for ESC with CAN ID [PKT_ID + 3]
    uint16_t pwmValueD; //!< The PWM (pulse width) command for ESC with CAN ID [PKT_ID + 4]
}ESC_CommandMultipleESCs_t;

//! Create the ESC_CommandMultipleESCs packet from parameters
void encodeESC_CommandMultipleESCsPacket(void* pkt, uint16_t pwmValueA, uint16_t pwmValueB, uint16_t pwmValueC, uint16_t pwmValueD, uint32_t id);

//! Decode the ESC_CommandMultipleESCs packet to parameters
int decodeESC_CommandMultipleESCsPacket(const void* pkt, uint16_t* pwmValueA, uint16_t* pwmValueB, uint16_t* pwmValueC, uint16_t* pwmValueD);

//! return the minimum encoded length for the ESC_CommandMultipleESCs packet
#define getESC_CommandMultipleESCsMinDataLength() (8)

//! return the maximum encoded length for the ESC_CommandMultipleESCs packet
#define getESC_CommandMultipleESCsMaxDataLength() (8)

//! Create the ESC_Disable packet from parameters
void encodeESC_DisablePacket(void* pkt);

//! Decode the ESC_Disable packet to parameters
int decodeESC_DisablePacket(const void* pkt);

//! return the packet ID for the ESC_Disable packet
#define getESC_DisablePacketID() (PKT_ESC_DISABLE)

//! return the minimum encoded length for the ESC_Disable packet
#define getESC_DisableMinDataLength() (2)

//! return the maximum encoded length for the ESC_Disable packet
#define getESC_DisableMaxDataLength() (2)

//! Create the ESC_Enable packet from parameters
void encodeESC_EnablePacket(void* pkt);

//! Decode the ESC_Enable packet to parameters
int decodeESC_EnablePacket(const void* pkt);

//! return the packet ID for the ESC_Enable packet
#define getESC_EnablePacketID() (PKT_ESC_STANDBY)

//! return the minimum encoded length for the ESC_Enable packet
#define getESC_EnableMinDataLength() (2)

//! return the maximum encoded length for the ESC_Enable packet
#define getESC_EnableMaxDataLength() (2)

//! Create the ESC_PWMCommand packet from parameters
void encodeESC_PWMCommandPacket(void* pkt, uint16_t pwmCommand);

//! Decode the ESC_PWMCommand packet to parameters
int decodeESC_PWMCommandPacket(const void* pkt, uint16_t* pwmCommand);

//! return the packet ID for the ESC_PWMCommand packet
#define getESC_PWMCommandPacketID() (PKT_ESC_PWM_CMD)

//! return the minimum encoded length for the ESC_PWMCommand packet
#define getESC_PWMCommandMinDataLength() (2)

//! return the maximum encoded length for the ESC_PWMCommand packet
#define getESC_PWMCommandMaxDataLength() (2)

//! Create the ESC_RPMCommand packet from parameters
void encodeESC_RPMCommandPacket(void* pkt, uint16_t rpmCommand);

//! Decode the ESC_RPMCommand packet to parameters
int decodeESC_RPMCommandPacket(const void* pkt, uint16_t* rpmCommand);

//! return the packet ID for the ESC_RPMCommand packet
#define getESC_RPMCommandPacketID() (PKT_ESC_RPM_CMD)

//! return the minimum encoded length for the ESC_RPMCommand packet
#define getESC_RPMCommandMinDataLength() (2)

//! return the maximum encoded length for the ESC_RPMCommand packet
#define getESC_RPMCommandMaxDataLength() (2)

//! Create the ESC_VoltageCommand packet from parameters
void encodeESC_VoltageCommandPacket(void* pkt, uint16_t voltageCommand);

//! Decode the ESC_VoltageCommand packet to parameters
int decodeESC_VoltageCommandPacket(const void* pkt, uint16_t* voltageCommand);

//! return the packet ID for the ESC_VoltageCommand packet
#define getESC_VoltageCommandPacketID() (PKT_ESC_VOLT_CMD)

//! return the minimum encoded length for the ESC_VoltageCommand packet
#define getESC_VoltageCommandMinDataLength() (2)

//! return the maximum encoded length for the ESC_VoltageCommand packet
#define getESC_VoltageCommandMaxDataLength() (2)

/*!
 * The ESC_STATUS_A packet contains high-priority ESC status information. This
 * packet is transmitted by the ESC at regular (user-configurable) intervals.
 * It can also be requested (polled) from the ESC by sending a zero-length
 * packet of the same type.
 */
typedef struct
{
    uint8_t          mode;    //!< ESC operating mode. The lower four bits indicate the operational mode of the ESC, in accordance with the ESCOperatingModes enumeration. The upper three bits are used for debugging and should be ignored for general use.
    ESC_StatusBits_t status;  //!< ESC status bits
    uint16_t         command; //!< ESC operational command - value depends on 'mode' available in this packet. If the ESC is disabled, data reads 0x0000. If the ESC is in open-loop PWM mode, this value is the PWM command in units of 1us, in the range 1000us to 2000us. If the ESC is in closed-loop RPM mode, this value is the RPM command in units of 1RPM
    uint16_t         rpm;     //!< Motor speed
}ESC_StatusA_t;

//! Create the ESC_StatusA packet
void encodeESC_StatusAPacketStructure(void* pkt, const ESC_StatusA_t* user);

//! Decode the ESC_StatusA packet
int decodeESC_StatusAPacketStructure(const void* pkt, ESC_StatusA_t* user);

//! Create the ESC_StatusA packet from parameters
void encodeESC_StatusAPacket(void* pkt, uint8_t mode, const ESC_StatusBits_t* status, uint16_t command, uint16_t rpm);

//! Decode the ESC_StatusA packet to parameters
int decodeESC_StatusAPacket(const void* pkt, uint8_t* mode, ESC_StatusBits_t* status, uint16_t* command, uint16_t* rpm);

//! return the packet ID for the ESC_StatusA packet
#define getESC_StatusAPacketID() (PKT_ESC_STATUS_A)

//! return the minimum encoded length for the ESC_StatusA packet
#define getESC_StatusAMinDataLength() (8)

//! return the maximum encoded length for the ESC_StatusA packet
#define getESC_StatusAMaxDataLength() (8)

/*!
 * The ESC_STATUS_B packet contains ESC operational information. This packet is
 * transmitted by the ESC at regular (user-configurable) intervals. It can also
 * be requested (polled) from the ESC by sending a zero-length packet of the
 * same type.
 */
typedef struct
{
    uint16_t voltage;          //!< ESC Rail Voltage
    int16_t  current;          //!< ESC Current. Current IN to the ESC is positive. Current OUT of the ESC is negative
    uint16_t dutyCycle;        //!< ESC Motor Duty Cycle
    int8_t   escTemperature;   //!< ESC Logic Board Temperature
    uint8_t  motorTemperature; //!< ESC Motor Temperature
}ESC_StatusB_t;

//! Create the ESC_StatusB packet
void encodeESC_StatusBPacketStructure(void* pkt, const ESC_StatusB_t* user);

//! Decode the ESC_StatusB packet
int decodeESC_StatusBPacketStructure(const void* pkt, ESC_StatusB_t* user);

//! Create the ESC_StatusB packet from parameters
void encodeESC_StatusBPacket(void* pkt, uint16_t voltage, int16_t current, uint16_t dutyCycle, int8_t escTemperature, uint8_t motorTemperature);

//! Decode the ESC_StatusB packet to parameters
int decodeESC_StatusBPacket(const void* pkt, uint16_t* voltage, int16_t* current, uint16_t* dutyCycle, int8_t* escTemperature, uint8_t* motorTemperature);

//! return the packet ID for the ESC_StatusB packet
#define getESC_StatusBPacketID() (PKT_ESC_STATUS_B)

//! return the minimum encoded length for the ESC_StatusB packet
#define getESC_StatusBMinDataLength() (8)

//! return the maximum encoded length for the ESC_StatusB packet
#define getESC_StatusBMaxDataLength() (8)

/*!
 * The ESC_STATUS_C packet contains ESC operational information. This packet is
 * transmitted by the ESC at regular intervals (user-configurable). It can also
 * be requested (polled) from the ESC by sending a zero-length packet of the
 * same type.
 */
typedef struct
{
    float    fetTemperature; //!< ESC Phase Board Temperature
    uint16_t pwmFrequency;   //!< Current motor PWM frequency (10 Hz per bit)
    uint16_t timingAdvance;  //!< Current timing advance (0.1 degree per bit)
}ESC_StatusC_t;

//! Create the ESC_StatusC packet
void encodeESC_StatusCPacketStructure(void* pkt, const ESC_StatusC_t* user);

//! Decode the ESC_StatusC packet
int decodeESC_StatusCPacketStructure(const void* pkt, ESC_StatusC_t* user);

//! Create the ESC_StatusC packet from parameters
void encodeESC_StatusCPacket(void* pkt, float fetTemperature, uint16_t pwmFrequency, uint16_t timingAdvance);

//! Decode the ESC_StatusC packet to parameters
int decodeESC_StatusCPacket(const void* pkt, float* fetTemperature, uint16_t* pwmFrequency, uint16_t* timingAdvance);

//! return the packet ID for the ESC_StatusC packet
#define getESC_StatusCPacketID() (PKT_ESC_STATUS_C)

//! return the minimum encoded length for the ESC_StatusC packet
#define getESC_StatusCMinDataLength() (7)

//! return the maximum encoded length for the ESC_StatusC packet
#define getESC_StatusCMaxDataLength() (7)

/*!
 * The ESC_STATUS_D packet contains ESC operational information. This packet is
 * transmitted by the ESC at regular intervals (user-configurable). It can also
 * be requested (polled) from the ESC by sending a zero-length packet of the
 * same type.
 */
typedef struct
{
    uint8_t demagAngle; //!< Measured demag angle of motor
}ESC_StatusD_t;

//! Create the ESC_StatusD packet
void encodeESC_StatusDPacketStructure(void* pkt, const ESC_StatusD_t* user);

//! Decode the ESC_StatusD packet
int decodeESC_StatusDPacketStructure(const void* pkt, ESC_StatusD_t* user);

//! Create the ESC_StatusD packet from parameters
void encodeESC_StatusDPacket(void* pkt, uint8_t demagAngle);

//! Decode the ESC_StatusD packet to parameters
int decodeESC_StatusDPacket(const void* pkt, uint8_t* demagAngle);

//! return the packet ID for the ESC_StatusD packet
#define getESC_StatusDPacketID() (PKT_ESC_STATUS_D)

//! return the minimum encoded length for the ESC_StatusD packet
#define getESC_StatusDMinDataLength() (8)

//! return the maximum encoded length for the ESC_StatusD packet
#define getESC_StatusDMaxDataLength() (8)

/*!
 * Warning and error status information. If any warning or error flags are set,
 * this packet is transmitted by the ESC at 10Hz. If there are no warning or
 * error flags set, the packet is transmitted by the ESC at 1Hz.
 */
typedef struct
{
    ESC_WarningBits_t warnings;         //!< ESC warning bitfield
    ESC_ErrorBits_t   errors;           //!< ESC error bitfield
    uint8_t           extended;         //!< Set to indicate that this packet contains extended warning and error information
    ESC_WarningBits_t warningsExtended; //!< Extension of ESC warning bitfield
    ESC_ErrorBits_t   errorsExtended;   //!< Extension of ESC error bifield
}ESC_WarningErrorStatus_t;

//! Create the ESC_WarningErrorStatus packet from parameters
void encodeESC_WarningErrorStatusPacket(void* pkt, const ESC_WarningBits_t* warnings, const ESC_ErrorBits_t* errors, uint8_t extended, const ESC_WarningBits_t* warningsExtended, const ESC_ErrorBits_t* errorsExtended);

//! Decode the ESC_WarningErrorStatus packet to parameters
int decodeESC_WarningErrorStatusPacket(const void* pkt, ESC_WarningBits_t* warnings, ESC_ErrorBits_t* errors, uint8_t* extended, ESC_WarningBits_t* warningsExtended, ESC_ErrorBits_t* errorsExtended);

//! return the packet ID for the ESC_WarningErrorStatus packet
#define getESC_WarningErrorStatusPacketID() (PKT_ESC_WARNINGS_ERRORS)

//! return the minimum encoded length for the ESC_WarningErrorStatus packet
#define getESC_WarningErrorStatusMinDataLength() (4)

//! return the maximum encoded length for the ESC_WarningErrorStatus packet
#define getESC_WarningErrorStatusMaxDataLength() (8)

/*!
 * This packet contains the current output values for the RPM controller.
 */
typedef struct
{
    float   pTerm; 
    float   iTerm; 
    float   fTerm; 
    int16_t output; //!< Output duty cycle
}ESC_ControlLoopOutputs_t;

//! Create the ESC_ControlLoopOutputs packet
void encodeESC_ControlLoopOutputsPacketStructure(void* pkt, const ESC_ControlLoopOutputs_t* user);

//! Decode the ESC_ControlLoopOutputs packet
int decodeESC_ControlLoopOutputsPacketStructure(const void* pkt, ESC_ControlLoopOutputs_t* user);

//! Create the ESC_ControlLoopOutputs packet from parameters
void encodeESC_ControlLoopOutputsPacket(void* pkt, float pTerm, float iTerm, float fTerm, int16_t output);

//! Decode the ESC_ControlLoopOutputs packet to parameters
int decodeESC_ControlLoopOutputsPacket(const void* pkt, float* pTerm, float* iTerm, float* fTerm, int16_t* output);

//! return the packet ID for the ESC_ControlLoopOutputs packet
#define getESC_ControlLoopOutputsPacketID() (PKT_ESC_CONTROL_LOOP_DATA)

//! return the minimum encoded length for the ESC_ControlLoopOutputs packet
#define getESC_ControlLoopOutputsMinDataLength() (8)

//! return the maximum encoded length for the ESC_ControlLoopOutputs packet
#define getESC_ControlLoopOutputsMaxDataLength() (8)

/*!
 * This packet contains information on the hall sensor
 */
typedef struct
{
    ESC_HallSensorPattern_t detectedPattern;
}ESC_HallSensorInfo_t;

//! Create the ESC_HallSensorInfo packet from parameters
void encodeESC_HallSensorInfoPacket(void* pkt, const ESC_HallSensorPattern_t* detectedPattern);

//! Decode the ESC_HallSensorInfo packet to parameters
int decodeESC_HallSensorInfoPacket(const void* pkt, ESC_HallSensorPattern_t* detectedPattern);

//! return the packet ID for the ESC_HallSensorInfo packet
#define getESC_HallSensorInfoPacketID() (PKT_ESC_HALL_SENSOR_INFO)

//! return the minimum encoded length for the ESC_HallSensorInfo packet
#define getESC_HallSensorInfoMinDataLength() (1)

//! return the maximum encoded length for the ESC_HallSensorInfo packet
#define getESC_HallSensorInfoMaxDataLength() (1)

/*!
 * Motor status flags. If any warning or error flags are set, this packet is
 * transmitted by the ESC at 10Hz. If there are no warning or error flags set,
 * the packet is transmitted by the ESC at 1Hz.
 */
typedef struct
{
    uint16_t standbyCause;     //!< Cause of most recent standby event
    uint16_t disableCause;     //!< Cause of most recent disable event
    uint16_t offCause;         //!< Cause of most recent motor-stop event
    uint16_t failedStartCause; //!< Cause of most recent failed-start
}ESC_MotorStatusFlags_t;

//! Create the ESC_MotorStatusFlags packet
void encodeESC_MotorStatusFlagsPacketStructure(void* pkt, const ESC_MotorStatusFlags_t* user);

//! Decode the ESC_MotorStatusFlags packet
int decodeESC_MotorStatusFlagsPacketStructure(const void* pkt, ESC_MotorStatusFlags_t* user);

//! Create the ESC_MotorStatusFlags packet from parameters
void encodeESC_MotorStatusFlagsPacket(void* pkt, uint16_t standbyCause, uint16_t disableCause, uint16_t offCause, uint16_t failedStartCause);

//! Decode the ESC_MotorStatusFlags packet to parameters
int decodeESC_MotorStatusFlagsPacket(const void* pkt, uint16_t* standbyCause, uint16_t* disableCause, uint16_t* offCause, uint16_t* failedStartCause);

//! return the packet ID for the ESC_MotorStatusFlags packet
#define getESC_MotorStatusFlagsPacketID() (PKT_ESC_MOTOR_FLAGS)

//! return the minimum encoded length for the ESC_MotorStatusFlags packet
#define getESC_MotorStatusFlagsMinDataLength() (8)

//! return the maximum encoded length for the ESC_MotorStatusFlags packet
#define getESC_MotorStatusFlagsMaxDataLength() (8)

/*!
 * Voltage control loop settings
 */
typedef struct
{
    ESC_ControlLoopCommon_t pid; //!< Core control loop settings
}ESC_VoltageControlLoopSettings_t;

//! Create the ESC_VoltageControlLoopSettings packet
void encodeESC_VoltageControlLoopSettingsPacketStructure(void* pkt, const ESC_VoltageControlLoopSettings_t* user);

//! Decode the ESC_VoltageControlLoopSettings packet
int decodeESC_VoltageControlLoopSettingsPacketStructure(const void* pkt, ESC_VoltageControlLoopSettings_t* user);

//! Create the ESC_VoltageControlLoopSettings packet from parameters
void encodeESC_VoltageControlLoopSettingsPacket(void* pkt, const ESC_ControlLoopCommon_t* pid);

//! Decode the ESC_VoltageControlLoopSettings packet to parameters
int decodeESC_VoltageControlLoopSettingsPacket(const void* pkt, ESC_ControlLoopCommon_t* pid);

//! return the packet ID for the ESC_VoltageControlLoopSettings packet
#define getESC_VoltageControlLoopSettingsPacketID() (PKT_ESC_VOLT_LOOP_SETTINGS)

//! return the minimum encoded length for the ESC_VoltageControlLoopSettings packet
#define getESC_VoltageControlLoopSettingsMinDataLength() (8)

//! return the maximum encoded length for the ESC_VoltageControlLoopSettings packet
#define getESC_VoltageControlLoopSettingsMaxDataLength() (11)

/*!
 * ESC self-protection settings
 */
typedef struct
{
    float    overcurrentBus;          //!< Maximum allowable DC bus current
    float    overcurrentPhase;        //!< Maximum allowable motor phase current
    float    overcurrentRegen;        //!< Maximum allowable regen current
    uint8_t  overtemperatureInternal; //!< Maximum allowable internal temperature
    uint8_t  overtemperatureMotor;    //!< Maximum allowable motor temperature
    uint16_t overspeed;               //!< Maximum motor speed
    uint8_t  undervoltage;            //!< ESC undervoltage warning threshold
    uint8_t  overvoltage;             //!< ESC overvoltage warning threshold
    uint8_t  demagAngle;              //!< Maximum allowable demag angle
    uint8_t  timingAdvance;           //!< Maximum allowable timing advance
}ESC_ProtectionValues_t;

//! Create the ESC_ProtectionValues packet
void encodeESC_ProtectionValuesPacketStructure(void* pkt, const ESC_ProtectionValues_t* user);

//! Decode the ESC_ProtectionValues packet
int decodeESC_ProtectionValuesPacketStructure(const void* pkt, ESC_ProtectionValues_t* user);

//! Create the ESC_ProtectionValues packet from parameters
void encodeESC_ProtectionValuesPacket(void* pkt, float overcurrentBus, float overcurrentPhase, float overcurrentRegen, uint8_t overtemperatureInternal, uint8_t overtemperatureMotor, uint16_t overspeed, uint8_t undervoltage, uint8_t overvoltage, uint8_t demagAngle, uint8_t timingAdvance);

//! Decode the ESC_ProtectionValues packet to parameters
int decodeESC_ProtectionValuesPacket(const void* pkt, float* overcurrentBus, float* overcurrentPhase, float* overcurrentRegen, uint8_t* overtemperatureInternal, uint8_t* overtemperatureMotor, uint16_t* overspeed, uint8_t* undervoltage, uint8_t* overvoltage, uint8_t* demagAngle, uint8_t* timingAdvance);

//! return the packet ID for the ESC_ProtectionValues packet
#define getESC_ProtectionValuesPacketID() (PKT_ESC_PROTECTION_LEVELS)

//! return the minimum encoded length for the ESC_ProtectionValues packet
#define getESC_ProtectionValuesMinDataLength() (10)

//! return the maximum encoded length for the ESC_ProtectionValues packet
#define getESC_ProtectionValuesMaxDataLength() (11)

/*!
 * ESC protection actions
 */
typedef struct
{
    uint8_t overcurrentBus;          //!< Action when bus current exceeds limit
    uint8_t overcurrentPhase;        //!< Action when phase current exceeds limit
    uint8_t overcurrentRegen;        //!< Action when regen current exceeds limit
    uint8_t overtemperatureInternal; //!< Action when ESC temperature exceeds limit
    uint8_t overtemperatureMotor;    //!< Action when motor temperature exceeds limit
    uint8_t overspeed;               //!< Action when motor speed exceeds limit
    uint8_t undervoltage;            //!< Action when DC voltage falls below configured lower limit
    uint8_t overvoltage;             //!< Action when DC voltage exceeds configured upper limit
    uint8_t demagAngle;              //!< Action when motor demag angle exceeds limit
    uint8_t commutationLoss;         //!< Action on motor commutation estimator failure
}ESC_ProtectionActions_t;

//! Create the ESC_ProtectionActions packet
void encodeESC_ProtectionActionsPacketStructure(void* pkt, const ESC_ProtectionActions_t* user);

//! Decode the ESC_ProtectionActions packet
int decodeESC_ProtectionActionsPacketStructure(const void* pkt, ESC_ProtectionActions_t* user);

//! Create the ESC_ProtectionActions packet from parameters
void encodeESC_ProtectionActionsPacket(void* pkt, uint8_t overcurrentBus, uint8_t overcurrentPhase, uint8_t overcurrentRegen, uint8_t overtemperatureInternal, uint8_t overtemperatureMotor, uint8_t overspeed, uint8_t undervoltage, uint8_t overvoltage, uint8_t demagAngle, uint8_t commutationLoss);

//! Decode the ESC_ProtectionActions packet to parameters
int decodeESC_ProtectionActionsPacket(const void* pkt, uint8_t* overcurrentBus, uint8_t* overcurrentPhase, uint8_t* overcurrentRegen, uint8_t* overtemperatureInternal, uint8_t* overtemperatureMotor, uint8_t* overspeed, uint8_t* undervoltage, uint8_t* overvoltage, uint8_t* demagAngle, uint8_t* commutationLoss);

//! return the packet ID for the ESC_ProtectionActions packet
#define getESC_ProtectionActionsPacketID() (PKT_ESC_PROTECTION_ACTIONS)

//! return the minimum encoded length for the ESC_ProtectionActions packet
#define getESC_ProtectionActionsMinDataLength() (3)

//! return the maximum encoded length for the ESC_ProtectionActions packet
#define getESC_ProtectionActionsMaxDataLength() (4)

/*!
 * Motor and system parameters
 */
typedef struct
{
    uint8_t  reserved;  //!< Reserved for future packet expansion. Field is encoded constant.
    uint16_t motorKv;   //!< Motor RPM constant
    uint8_t  polePairs; //!< Motor pole pairs count
    uint16_t maxSpeed;  //!< Maximum motor speed
}ESC_MotorParameters_t;

//! Create the ESC_MotorParameters packet
void encodeESC_MotorParametersPacketStructure(void* pkt, const ESC_MotorParameters_t* user);

//! Decode the ESC_MotorParameters packet
int decodeESC_MotorParametersPacketStructure(const void* pkt, ESC_MotorParameters_t* user);

//! return the packet ID for the ESC_MotorParameters packet
#define getESC_MotorParametersPacketID() (PKT_ESC_MOTOR_PARAMETERS)

//! return the minimum encoded length for the ESC_MotorParameters packet
#define getESC_MotorParametersMinDataLength() (4)

//! return the maximum encoded length for the ESC_MotorParameters packet
#define getESC_MotorParametersMaxDataLength() (6)

/*!
 * Hall sensor configuration options
 */
typedef struct
{
    bool     bypassStartingChecks; //!< Bypass extra checks for starting in hall sensor mode
    uint8_t  mode;                 //!< Hall sensor operational mode
    uint8_t  polarity;             //!< Hall sensor U/V/W polarity
    uint16_t timeout;              //!< Time (in milliseconds) for no hall sensor transitions to trigger an error (0 = forever)
    uint16_t maxSpeed;             //!< Maximum electrical RPM when running under hall sensor control
    uint16_t transitionSpeed;      //!< RPM threshold for transferring to sensorless motor control
    uint8_t  transitionHysteresis; //!< RPM hysteresis for switching between sensored and sensorless control
}ESC_MotorHallSensorConfig_t;

//! Create the ESC_MotorHallSensorConfig packet
void encodeESC_MotorHallSensorConfigPacketStructure(void* pkt, const ESC_MotorHallSensorConfig_t* user);

//! Decode the ESC_MotorHallSensorConfig packet
int decodeESC_MotorHallSensorConfigPacketStructure(const void* pkt, ESC_MotorHallSensorConfig_t* user);

//! return the packet ID for the ESC_MotorHallSensorConfig packet
#define getESC_MotorHallSensorConfigPacketID() (PKT_ESC_MOTOR_HALL_CONFIG)

//! return the minimum encoded length for the ESC_MotorHallSensorConfig packet
#define getESC_MotorHallSensorConfigMinDataLength() (9)

//! return the maximum encoded length for the ESC_MotorHallSensorConfig packet
#define getESC_MotorHallSensorConfigMaxDataLength() (9)

/*!
 * This packet contains the serial number for the ESC. Additionally there are
 * two extra values (each 16-bit) which can be programmed by the user for any
 * purpose.
 */
typedef struct
{
    uint8_t  HardwareRevision; //!< ESC hardware revision (OTP - not configurable by user)
    uint8_t  Model;            //!< ESC model (OTP - not configurable by user)
    uint16_t SerialNumber;     //!< ESC Serial Number (OTP - not configurable by user)
    uint16_t UserIDA;          //!< User ID Value A - user can set this value to any value
    uint16_t UserIDB;          //!< User ID Value B - user can set this value to any value
}ESC_Address_t;

//! Create the ESC_Address packet
void encodeESC_AddressPacketStructure(void* pkt, const ESC_Address_t* user);

//! Decode the ESC_Address packet
int decodeESC_AddressPacketStructure(const void* pkt, ESC_Address_t* user);

//! Create the ESC_Address packet from parameters
void encodeESC_AddressPacket(void* pkt, uint8_t HardwareRevision, uint8_t Model, uint16_t SerialNumber, uint16_t UserIDA, uint16_t UserIDB);

//! Decode the ESC_Address packet to parameters
int decodeESC_AddressPacket(const void* pkt, uint8_t* HardwareRevision, uint8_t* Model, uint16_t* SerialNumber, uint16_t* UserIDA, uint16_t* UserIDB);

//! return the packet ID for the ESC_Address packet
#define getESC_AddressPacketID() (PKT_ESC_SERIAL_NUMBER)

//! return the minimum encoded length for the ESC_Address packet
#define getESC_AddressMinDataLength() (8)

//! return the maximum encoded length for the ESC_Address packet
#define getESC_AddressMaxDataLength() (8)

/*!
 * This packet contains a zero-terminated string (max-length 8) used to
 * identify the particular ESC.
 */
typedef struct
{
    uint8_t ESCTitle[8]; //!< Description of this ESC
}ESC_Title_t;

//! Create the ESC_Title packet
void encodeESC_TitlePacketStructure(void* pkt, const ESC_Title_t* user);

//! Decode the ESC_Title packet
int decodeESC_TitlePacketStructure(const void* pkt, ESC_Title_t* user);

//! Create the ESC_Title packet from parameters
void encodeESC_TitlePacket(void* pkt, const uint8_t ESCTitle[8]);

//! Decode the ESC_Title packet to parameters
int decodeESC_TitlePacket(const void* pkt, uint8_t ESCTitle[8]);

//! return the packet ID for the ESC_Title packet
#define getESC_TitlePacketID() (PKT_ESC_TITLE)

//! return the minimum encoded length for the ESC_Title packet
#define getESC_TitleMinDataLength() (8)

//! return the maximum encoded length for the ESC_Title packet
#define getESC_TitleMaxDataLength() (8)

/*!
 * This packet contains the firmware version of the ESC
 */
typedef struct
{
    uint8_t  versionMajor;     //!< Major firmware version number
    uint8_t  versionMinor;     //!< Minor firmware version numner
    uint8_t  versionDay;       //!< Firmware release date, day-of-month
    uint8_t  versionMonth;     //!< Firmware release data, month-of-year
    uint16_t versionYear;      //!< Firmware release date, year
    uint16_t firmwareChecksum; //!< Firmware checksum
}ESC_Firmware_t;

//! Create the ESC_Firmware packet
void encodeESC_FirmwarePacketStructure(void* pkt, const ESC_Firmware_t* user);

//! Decode the ESC_Firmware packet
int decodeESC_FirmwarePacketStructure(const void* pkt, ESC_Firmware_t* user);

//! Create the ESC_Firmware packet from parameters
void encodeESC_FirmwarePacket(void* pkt, uint8_t versionMajor, uint8_t versionMinor, uint8_t versionDay, uint8_t versionMonth, uint16_t versionYear, uint16_t firmwareChecksum);

//! Decode the ESC_Firmware packet to parameters
int decodeESC_FirmwarePacket(const void* pkt, uint8_t* versionMajor, uint8_t* versionMinor, uint8_t* versionDay, uint8_t* versionMonth, uint16_t* versionYear, uint16_t* firmwareChecksum);

//! return the packet ID for the ESC_Firmware packet
#define getESC_FirmwarePacketID() (PKT_ESC_FIRMWARE)

//! return the minimum encoded length for the ESC_Firmware packet
#define getESC_FirmwareMinDataLength() (8)

//! return the maximum encoded length for the ESC_Firmware packet
#define getESC_FirmwareMaxDataLength() (8)

/*!
 * This packet contains system runtime information
 */
typedef struct
{
    uint32_t millisecondsSinceReset; //!< Number of milliseconds since the ESC last experienced a reset/power-on event
    uint16_t powerCycles;            //!< Number of power cycle events that the ESC has experienced
    uint8_t  resetCode;              //!< Processor RESET code for debug purposes
    uint8_t  cpuOccupancy;           //!< Processor usage
}ESC_SystemInfo_t;

//! Create the ESC_SystemInfo packet
void encodeESC_SystemInfoPacketStructure(void* pkt, const ESC_SystemInfo_t* user);

//! Decode the ESC_SystemInfo packet
int decodeESC_SystemInfoPacketStructure(const void* pkt, ESC_SystemInfo_t* user);

//! Create the ESC_SystemInfo packet from parameters
void encodeESC_SystemInfoPacket(void* pkt, uint32_t millisecondsSinceReset, uint16_t powerCycles, uint8_t resetCode, uint8_t cpuOccupancy);

//! Decode the ESC_SystemInfo packet to parameters
int decodeESC_SystemInfoPacket(const void* pkt, uint32_t* millisecondsSinceReset, uint16_t* powerCycles, uint8_t* resetCode, uint8_t* cpuOccupancy);

//! return the packet ID for the ESC_SystemInfo packet
#define getESC_SystemInfoPacketID() (PKT_ESC_SYSTEM_INFO)

//! return the minimum encoded length for the ESC_SystemInfo packet
#define getESC_SystemInfoMinDataLength() (8)

//! return the maximum encoded length for the ESC_SystemInfo packet
#define getESC_SystemInfoMaxDataLength() (8)

/*!
 * This packet contains the telemetry packet configuration
 */
typedef struct
{
    ESC_TelemetryConfig_t settings;      //!< Telemetry settings
    char                  apiVersion[5]; //!< The API version of the ESC. Field is encoded constant.
}ESC_TelemetrySettings_t;

//! Create the ESC_TelemetrySettings packet
void encodeESC_TelemetrySettingsPacketStructure(void* pkt, const ESC_TelemetrySettings_t* user);

//! Decode the ESC_TelemetrySettings packet
int decodeESC_TelemetrySettingsPacketStructure(const void* pkt, ESC_TelemetrySettings_t* user);

//! Create the ESC_TelemetrySettings packet from parameters
void encodeESC_TelemetrySettingsPacket(void* pkt, const ESC_TelemetryConfig_t* settings);

//! Decode the ESC_TelemetrySettings packet to parameters
int decodeESC_TelemetrySettingsPacket(const void* pkt, ESC_TelemetryConfig_t* settings, char apiVersion[5]);

//! return the packet ID for the ESC_TelemetrySettings packet
#define getESC_TelemetrySettingsPacketID() (PKT_ESC_TELEMETRY_SETTINGS)

//! return the minimum encoded length for the ESC_TelemetrySettings packet
#define getESC_TelemetrySettingsMinDataLength() (4)

//! return the maximum encoded length for the ESC_TelemetrySettings packet
#define getESC_TelemetrySettingsMaxDataLength() (8)

/*!
 * This packet contains information on the non-volatile ESC settings
 */
typedef struct
{
    bool     settingsLocked;    //!< Set if the ESC settings are locked
    uint8_t  version;           //!< Version of EEPROM data
    uint16_t size;              //!< Size of settings data
    uint16_t checksum;          //!< Settings checksum
    uint16_t validatedChecksum; //!< Validated settings checksum
}ESC_EEPROMSettings_t;

//! Create the ESC_EEPROMSettings packet
void encodeESC_EEPROMSettingsPacketStructure(void* pkt, const ESC_EEPROMSettings_t* user);

//! Decode the ESC_EEPROMSettings packet
int decodeESC_EEPROMSettingsPacketStructure(const void* pkt, ESC_EEPROMSettings_t* user);

//! Create the ESC_EEPROMSettings packet from parameters
void encodeESC_EEPROMSettingsPacket(void* pkt, bool settingsLocked, uint8_t version, uint16_t size, uint16_t checksum, uint16_t validatedChecksum);

//! Decode the ESC_EEPROMSettings packet to parameters
int decodeESC_EEPROMSettingsPacket(const void* pkt, bool* settingsLocked, uint8_t* version, uint16_t* size, uint16_t* checksum, uint16_t* validatedChecksum);

//! return the packet ID for the ESC_EEPROMSettings packet
#define getESC_EEPROMSettingsPacketID() (PKT_ESC_EEPROM)

//! return the minimum encoded length for the ESC_EEPROMSettings packet
#define getESC_EEPROMSettingsMinDataLength() (5)

//! return the maximum encoded length for the ESC_EEPROMSettings packet
#define getESC_EEPROMSettingsMaxDataLength() (7)

/*!
 * Motor temperature sensor settings
 */
typedef struct
{
    int16_t  NTC_T[3]; //!< Reference temperature values
    float    NTC_R[3]; //!< Reference resistance values
    uint16_t Beta;     //!< Beta constant
}ESC_TempSensorConfig_t;

//! Create the ESC_TempSensorConfig packet
void encodeESC_TempSensorConfigPacketStructure(void* pkt, const ESC_TempSensorConfig_t* user);

//! Decode the ESC_TempSensorConfig packet
int decodeESC_TempSensorConfigPacketStructure(const void* pkt, ESC_TempSensorConfig_t* user);

//! Create the ESC_TempSensorConfig packet from parameters
void encodeESC_TempSensorConfigPacket(void* pkt, const int16_t NTC_T[3], const float NTC_R[3], uint16_t Beta);

//! Decode the ESC_TempSensorConfig packet to parameters
int decodeESC_TempSensorConfigPacket(const void* pkt, int16_t NTC_T[3], float NTC_R[3], uint16_t* Beta);

//! return the packet ID for the ESC_TempSensorConfig packet
#define getESC_TempSensorConfigPacketID() (PKT_ESC_MOTOR_TEMP_SENSOR)

//! return the minimum encoded length for the ESC_TempSensorConfig packet
#define getESC_TempSensorConfigMinDataLength() (20)

//! return the maximum encoded length for the ESC_TempSensorConfig packet
#define getESC_TempSensorConfigMaxDataLength() (20)

/*!
 * ESC telltale values
 */
typedef struct
{
    uint8_t  maxTemperature;      //!< Maximum recorded internal temperature
    uint8_t  maxFetTemperature;   //!< Maximum recorded MOSFET temperature
    uint8_t  maxMotorTemperature; //!< Maximum recorded motor temperature
    uint8_t  maxRippleVoltage;    //!< Maximum recorded battery voltage
    float    maxBatteryCurrent;   //!< Maximum recorded battery current
    float    maxRegenCurrent;     //!< Maximum recorded regen current
    uint16_t totalStarts;         //!< Number of successful motor start events
    uint16_t failedStarts;        //!< Number of failed motor start events
    uint32_t escRunTime;          //!< ESC run time
    uint32_t motorRunTime;        //!< Motor run time
    uint32_t desyncEvents;        //!< Number of recorded motor desync events
}ESC_TelltaleValues_t;

//! Create the ESC_TelltaleValues packet
void encodeESC_TelltaleValuesPacketStructure(void* pkt, const ESC_TelltaleValues_t* user);

//! Decode the ESC_TelltaleValues packet
int decodeESC_TelltaleValuesPacketStructure(const void* pkt, ESC_TelltaleValues_t* user);

//! Create the ESC_TelltaleValues packet from parameters
void encodeESC_TelltaleValuesPacket(void* pkt, uint8_t maxTemperature, uint8_t maxFetTemperature, uint8_t maxMotorTemperature, uint8_t maxRippleVoltage, float maxBatteryCurrent, float maxRegenCurrent, uint16_t totalStarts, uint16_t failedStarts, uint32_t escRunTime, uint32_t motorRunTime, uint32_t desyncEvents);

//! Decode the ESC_TelltaleValues packet to parameters
int decodeESC_TelltaleValuesPacket(const void* pkt, uint8_t* maxTemperature, uint8_t* maxFetTemperature, uint8_t* maxMotorTemperature, uint8_t* maxRippleVoltage, float* maxBatteryCurrent, float* maxRegenCurrent, uint16_t* totalStarts, uint16_t* failedStarts, uint32_t* escRunTime, uint32_t* motorRunTime, uint32_t* desyncEvents);

//! return the packet ID for the ESC_TelltaleValues packet
#define getESC_TelltaleValuesPacketID() (PKT_ESC_TELLTALES)

//! return the minimum encoded length for the ESC_TelltaleValues packet
#define getESC_TelltaleValuesMinDataLength() (3)

//! return the maximum encoded length for the ESC_TelltaleValues packet
#define getESC_TelltaleValuesMaxDataLength() (24)

/*!
 * Git commit hash for the ESC firmware
 */
typedef struct
{
    char hash[8]; //!< git commit hash
}ESC_GitHash_t;

//! Create the ESC_GitHash packet
void encodeESC_GitHashPacketStructure(void* pkt, const ESC_GitHash_t* user);

//! Decode the ESC_GitHash packet
int decodeESC_GitHashPacketStructure(const void* pkt, ESC_GitHash_t* user);

//! Create the ESC_GitHash packet from parameters
void encodeESC_GitHashPacket(void* pkt, const char hash[8]);

//! Decode the ESC_GitHash packet to parameters
int decodeESC_GitHashPacket(const void* pkt, char hash[8]);

//! return the packet ID for the ESC_GitHash packet
#define getESC_GitHashPacketID() (PKT_ESC_GIT_HASH)

//! return the minimum encoded length for the ESC_GitHash packet
#define getESC_GitHashMinDataLength() (1)

//! return the maximum encoded length for the ESC_GitHash packet
#define getESC_GitHashMaxDataLength() (8)

/*!
 * PWM input calibration
 */
typedef struct
{
    bool     glitchFilter; //!< Enable median glitch filter for PWM input
    uint8_t  protocol;     //!< Protocol version (reserved for future use). Field is encoded constant.
    int8_t   pwmOffset;    //!< PWM offset compensation value
    uint16_t inputMin;     //!< PWM value corresponding with 0% throttle
    uint16_t inputMax;     //!< PWM value corresponding with 1000% throttle
    uint16_t armThreshold; //!< PWM arming threshold
}ESC_PWMInputCalibration_t;

//! Create the ESC_PWMInputCalibration packet
void encodeESC_PWMInputCalibrationPacketStructure(void* pkt, const ESC_PWMInputCalibration_t* user);

//! Decode the ESC_PWMInputCalibration packet
int decodeESC_PWMInputCalibrationPacketStructure(const void* pkt, ESC_PWMInputCalibration_t* user);

//! Create the ESC_PWMInputCalibration packet from parameters
void encodeESC_PWMInputCalibrationPacket(void* pkt, bool glitchFilter, int8_t pwmOffset, uint16_t inputMin, uint16_t inputMax, uint16_t armThreshold);

//! Decode the ESC_PWMInputCalibration packet to parameters
int decodeESC_PWMInputCalibrationPacket(const void* pkt, bool* glitchFilter, uint8_t* protocol, int8_t* pwmOffset, uint16_t* inputMin, uint16_t* inputMax, uint16_t* armThreshold);

//! return the packet ID for the ESC_PWMInputCalibration packet
#define getESC_PWMInputCalibrationPacketID() (PKT_ESC_PWM_INPUT_CALIBRATION)

//! return the minimum encoded length for the ESC_PWMInputCalibration packet
#define getESC_PWMInputCalibrationMinDataLength() (8)

//! return the maximum encoded length for the ESC_PWMInputCalibration packet
#define getESC_PWMInputCalibrationMaxDataLength() (8)

#ifdef __cplusplus
}
#endif
#endif // _ESCPACKETS_H