ESP32 Forum

Code: Select all

#include <Arduino.h>
#include "esp32-hal.h"      // lots in this, including HW timer definitions
#define POT_PIN 34          // potentiometer pin
#define ESC_PIN 5           // ESC control pin
#define FWD_REV_PIN 21      // HIGH is forward, LOW is reverse
#define MOTOR_POLES 14      // seems to be correct for my 2200KV motor
#define TMR_CHAN 0          // HW timer channel
#define BOARD_MHZ 80        // used as prescale in timerBegin call
#define COUNT_UP true       // HW timer count direction
#define TX_NO_RX true       // only send data to ESC for now
#define TELEM_ON true       // but we'll be commanding off for now

// DShot 600 has frame rate of 600 kHz, which is 133 ticks of a 80MHz clock
#define SHORT_TICKS 44      // results in 555 nsec
#define LONG_TICKS 89       // results in 1111 nsec; total is 133 ticks of 80MHz clock

rmt_data_t dshotPacket[16]; // structure defined in esp32_hal_h ?
rmt_obj_t* rmt_send = NULL;
//
//uint8_t receivedBytes = 0;
//volatile bool requestTelemetry = false;
//bool printTelemetry = true;

volatile uint16_t dshotUserInputValue = 0; // holds the pot reading for speed to be sent in packet

// Note: The following lines marked with *nn were taken from HW timer tutorial at
// https://techtutorialsx.com/2017/10/07/esp32-arduino-timer-interrupts/ (blank lines not numbered
volatile int interruptCounter = 0;                    // *1 counts the interrupts from timer. volitile to make it persistent
int totalInterruptCounter;                            // *2
hw_timer_t * timer = NULL;                            // *4
portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED; // *5 used to maintain sync between interupt and loop code

void IRAM_ATTR onTimer() {                            // *7 ISR (interrupt service routine) for HW timer
  portENTER_CRITICAL_ISR(&timerMux);                  // *8
  interruptCounter++;                                 // *9
  dshotOutput(dshotUserInputValue, false);            // send out the 16 bit digital command to ESC
  portEXIT_CRITICAL_ISR(&timerMux);                   // *10
}                                                     // *12

void setup() {                                        // *14
  Serial.begin(115200);                               // *16
  Serial.print("init starting\n");
  pinMode(POT_PIN, INPUT);
  pinMode(FWD_REV_PIN, INPUT_PULLUP);
  pinMode(ESC_PIN, OUTPUT);
  rmt_send = rmtInit(ESC_PIN, TX_NO_RX, RMT_MEM_64);
  if (rmt_send == NULL) {
    Serial.println("init sender failed\n");
  }
  Serial.print("init sender success\n");
  float realTick = rmtSetTick(rmt_send, 12.5);        // 12.5 nsec sample rate
  Serial.printf("rmt_send tick set to: %fns\n", realTick);
  while (millis() < 3500) {
    dshotOutput(0, !TELEM_ON);
    delay(1);
  }
  timer = timerBegin(TMR_CHAN, BOARD_MHZ, COUNT_UP);   // *18 returns pointer to timer structure
  timerAttachInterrupt(timer, &onTimer, true);         // *19 attatch timer interupt to onTimer routine defined above: edge type=true
  timerAlarmWrite(timer, 1000, true);                  // *20 1000 and prescale of 80 is a msec. reload the timeer=true
  timerAlarmEnable(timer);                             // *21 timer is now set up and attached correctly
}                                                      // *23

void loop() {
  //  printTelemetry = false ;
  uint16_t dUR = analogRead(POT_PIN);                  // read the pot pin 0 - 4095
  dshotUserInputValue = map(dUR, 0, 4095, 48, 1047);   // 1 to 47 commands are reserved
  bool goforward = digitalRead(FWD_REV_PIN);
  if (!goforward) {
    dshotUserInputValue = map(dUR, 0, 4095, 1049, 2097);
  }
  if (dUR < 2) dshotUserInputValue = 0;
  if (interruptCounter > 0) {                          // *27 true if it's time to enter interrupt code
    portENTER_CRITICAL(&timerMux);                     // *29
    interruptCounter--;                                // *30
    portEXIT_CRITICAL(&timerMux);                      // *31
    totalInterruptCounter++;                           // *33
    Serial.printf("forward:%d, pot: %i   totalinterruptcounter: %i \n", goforward, dshotUserInputValue, totalInterruptCounter); // *35,36
  }
}

void dshotOutput(uint16_t value, bool telemetry) { // creates packet to send
  uint16_t packet;
  if (telemetry) {
    packet = (value << 1) | 1;
  } else {
    packet = (value << 1) | 0;
  }
  int csum = 0;                                    // holds checksum part of packet?
  int csum_data = packet;
  for (int i = 0; i < 3; i++) {
    csum ^=  csum_data;
    csum_data >>= 4;
  }
  csum &= 0xf;
  packet = (packet << 4) | csum;

  for (int i = 0; i < 16; i++) {
    dshotPacket[i].level0 = 1;
    dshotPacket[i].level1 = 0;
    if (packet & 0x8000) {                 // true for bit set
      dshotPacket[i].duration0 = LONG_TICKS;
      dshotPacket[i].duration1 = SHORT_TICKS;
    } else {                               // true for bit clear
      dshotPacket[i].duration0 = SHORT_TICKS;
      dshotPacket[i].duration1 = LONG_TICKS;
    }
    packet <<= 1;
  }
  rmtWrite(rmt_send, dshotPacket, 16);
  return;
}

Code: Select all

  uint16_t cmd = 0;                                  // Code that waits for chirps to finish?
  Serial.print("Sending command "); Serial.println(cmd);
  long int Tnow = millis();
  while (millis() < Tnow + 3500) {                      
    dshotOutput(cmd, !TELEM_ON);
    delay(2);
  }

  Serial.println("Tone finished?");

  cmd = 10;                                             // Set to 3D mode
  Serial.print("Sending command "); Serial.println(cmd);
  Tnow = millis();
  while (millis() < Tnow + 3000) {
    dshotOutput(cmd, !TELEM_ON);
    delay(2);
  }

  cmd = 12;                                             // save changes command
  Serial.print("Sending command "); Serial.println(cmd);
  Tnow = millis();
  while (millis() < Tnow + 3000) {
    dshotOutput(cmd, !TELEM_ON);
    delay(2);
  }
  Serial.println("Setup commands finished");