esc_dshot.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Alexandre Bustico <alexandre.bustico@enac.fr>
 *                    Gautier Hattenberger <gautier.hattenberger@enac.fr>
 *
 * This file is part of paparazzi
 *
 * paparazzi 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 2, or (at your option)
 * any later version.
 *
 * paparazzi 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 paparazzi; see the file COPYING.  If not, see
 * <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <ch.h>
#include <hal.h>
#include "mcu_periph/hal_stm32_dma.h"
 
#ifndef DSHOT_AT_LEAST_ONE_32B_TIMER
#define DSHOT_AT_LEAST_ONE_32B_TIMER TRUE
#endif
 
#ifndef DSHOT_CHANNEL_FIRST_INDEX
#define DSHOT_CHANNEL_FIRST_INDEX 0U
#endif
 
#define DSHOT_BIT_WIDTHS              16U
#define DSHOT_PRE_FRAME_SILENT_SYNC_BITS  2U
#define DSHOT_POST_FRAME_SILENT_SYNC_BITS 2U
#define DSHOT_DMA_BUFFER_SIZE       (DSHOT_BIT_WIDTHS + \
               DSHOT_PRE_FRAME_SILENT_SYNC_BITS + \
               DSHOT_POST_FRAME_SILENT_SYNC_BITS )
 
#define DSHOT_CHANNELS                4U // depend on the number of channels per timer
 
#define DSHOT_ALL_MOTORS 255U
 
typedef enum {
  DSHOT_UNINIT = 0,                       
  DSHOT_STOP,                             
  DSHOT_READY,                            
  DSHOT_ONGOING_TELEMETRY_QUERY,          
  DSHOT_ERROR                             
} dshotstate_t;
 
/*
  DshotSettingRequest (KISS24). Spin direction,
  3d and save Settings require 10 requests.. and the
  TLM Byte must always be high if 1-47 are used to send settings
 
  3D Mode:
  0 = stop
  48   (low) - 1047 (high) -> negative direction
  1048 (low) - 2047 (high) -> positive direction
 */
 
typedef enum {
  DSHOT_CMD_MOTOR_STOP = 0,
  DSHOT_CMD_BEACON1,
  DSHOT_CMD_BEACON2,
  DSHOT_CMD_BEACON3,
  DSHOT_CMD_BEACON4,
  DSHOT_CMD_BEACON5,
  DSHOT_CMD_ESC_INFO, // V2 includes settings
  DSHOT_CMD_SPIN_DIRECTION_1,
  DSHOT_CMD_SPIN_DIRECTION_2,
  DSHOT_CMD_3D_MODE_OFF,
  DSHOT_CMD_3D_MODE_ON,
  DSHOT_CMD_SETTINGS_REQUEST, // Currently not implemented
  DSHOT_CMD_SAVE_SETTINGS,
  DSHOT_CMD_SPIN_DIRECTION_NORMAL = 20,
  DSHOT_CMD_SPIN_DIRECTION_REVERSED = 21,
  DSHOT_CMD_LED0_ON, // BLHeli32 only
  DSHOT_CMD_LED1_ON, // BLHeli32 only
  DSHOT_CMD_LED2_ON, // BLHeli32 only
  DSHOT_CMD_LED3_ON, // BLHeli32 only
  DSHOT_CMD_LED0_OFF, // BLHeli32 only
  DSHOT_CMD_LED1_OFF, // BLHeli32 only
  DSHOT_CMD_LED2_OFF, // BLHeli32 only
  DSHOT_CMD_LED3_OFF, // BLHeli32 only
  DSHOT_CMD_AUDIO_STREAM_MODE_ON_OFF = 30, // KISS audio Stream mode on/Off
  DSHOT_CMD_SILENT_MODE_ON_OFF = 31, // KISS silent Mode on/Off
  DSHOT_CMD_MAX = 47
} dshot_special_commands_t;
 
typedef struct {
  union {
    struct {
      uint8_t  temp;
      uint16_t voltage;
      uint16_t current;
      uint16_t consumption;
      uint16_t rpm;
    } __attribute__((__packed__, scalar_storage_order("big-endian")));
    uint8_t rawData[9];
  };
  uint8_t  crc8;
}  __attribute__((__packed__)) DshotTelemetry ;
 
typedef union {
#if DSHOT_AT_LEAST_ONE_32B_TIMER
  uint32_t widths32[DSHOT_DMA_BUFFER_SIZE][DSHOT_CHANNELS];
#endif
  uint16_t widths16[DSHOT_DMA_BUFFER_SIZE][DSHOT_CHANNELS];
} DshotDmaBuffer;   // alignment to satisfy dma requirement
 
typedef struct DSHOTDriver DSHOTDriver;
 
 
typedef struct  {
  uint32_t  dma_stream;
 
  uint8_t dma_channel;
 
  PWMDriver *pwmp;
 
  SerialDriver  *tlm_sd;
 
  DshotDmaBuffer *dma_buf;
 
#if __DCACHE_PRESENT
 
  bool     dcache_memory_in_use;
#endif
} DSHOTConfig;
 
void     dshotStart(DSHOTDriver *driver, const DSHOTConfig *config);
void     dshotSetThrottle(DSHOTDriver *driver, const uint8_t index, const uint16_t throttle);
void     dshotSendFrame(DSHOTDriver *driver);
void     dshotSendThrottles(DSHOTDriver *driver, const uint16_t throttles[DSHOT_CHANNELS]);
void     dshotSendSpecialCommand(DSHOTDriver *driver, const uint8_t index, const dshot_special_commands_t specmd);
 
uint32_t dshotGetCrcErrorsCount(DSHOTDriver *driver);
const DshotTelemetry *dshotGetTelemetry(const DSHOTDriver *driver, const uint32_t index);
 
 
/*
#                 _ __           _                    _
#                | '_ \         (_)                  | |
#                | |_) |  _ __   _   __   __   __ _  | |_     ___
#                | .__/  | '__| | |  \ \ / /  / _` | | __|   / _ \
#                | |     | |    | |   \ V /  | (_| | \ |_   |  __/
#                |_|     |_|    |_|    \_/    \__,_|  \__|   \___|
*/
 
typedef union {
  struct {
    uint16_t crc: 4;
    uint16_t telemetryRequest: 1;
    uint16_t throttle: 11;
  };
  uint16_t rawFrame;
} DshotPacket;
 
typedef struct {
  DshotPacket       dp[DSHOT_CHANNELS];
  DshotTelemetry    dt[DSHOT_CHANNELS];
  volatile uint8_t  currentTlmQry;
  volatile bool     onGoingQry;
} DshotPackets;
 
 
struct  DSHOTDriver {
  const DSHOTConfig *config;
 
  DMAConfig dma_conf;
 
  PWMConfig pwm_conf;
 
  DMADriver dmap;
 
  msg_t  _mbBuf[1];
 
  mailbox_t mb;
 
  uint32_t crc_errors;
 
  THD_WORKING_AREA(waDshotTlmRec, 512);
 
  DshotPackets dshotMotors;
};