4. Generate PPM

Generate PPM

  • C

    Hi all, I would like to send a PPM to this transmitter to control gimbal axes (PAN,TILT,ROL) with M5Stack gyro remotely.
    the only sketch I found to generate PPM is for Arduino and use timer interrupt

    //https://forum.arduino.cc/index.php/topic,163199.msg1220724.html#msg1220724

// Started 18 Apr 2013 - the loco chassis is more or less ready for testing.
//
// This is a test program to drive a loco on R/C channel 1 based on the position of a potentiometer.
//
// The centre connection of the pot is connected to pin A2
// The control signal from the Arduino to the transmitter is on Pin D7.
//
// I intend that parts of this program will be used in the computer controlled version.
//
// The R/C receiver is programmed to treat the centre value (128?) as off with 0 and 255 representing
//    full forward and full reverse. Some experimentation will probably be necessary to determine the
//    correct 0 point.
// The transmitter can receive a sequence of pulses for 2 to 7 channels. For this program pulses will be
//    prepared for 7 channels with channels 2 to 7 being values that correspond to centre off.
//    The receiver would not work with only 3 channels - it needs at least 4..
//
// The Transmitter expects a sequence of pulses each of whose width (duration) conveys the
//   speed setting. The pulse lengths must vary between 1.0 and 2.0 millisecs with 1.5ms representing
//   centre off. Each pulse must be separated by a short pulse of 0.3ms and there must be a long pulse
//   to separate the groups of pulses. Ideally the group of pulses should repeat every 22ms
//   So, 2.0 + 0.3ms for 7 pulses takes 16.1ms thus requiring a separating pulse of 5.9ms.
//
// The pulses are generated by timer1 (16 bit) interrupts and to simpify matters when the computer is
//    controlling things the numbers needed to produce the sequence of pulse lengths will be stored
//    in an array. At each interrupt the next value in the array is used to set the duration for the
//    following interrupt. For this program the values in the array position corresponding to channel 3
//    will be derived from the potentiometer position. (The Rx seems to be programmed to drive the motor
//      on ch3).
//
// Timer1 is used because the longer periods afforded by the 16bits are needed. The prescaler is set
//    to divide the CPU clock by 64 giving a timer clock of 250khz or 4 microsecs (4us).
//    On that basis 0.3ms requires a delay of 75 clock steps
//                  1.0                      250
//                  1.5                      375
//                  2.0                      500
//                  5.9                     1475
//                 15.1                     3775
//
// This program only communicates with the PC for program testing.

// Data variables
unsigned int ppm[16]; // the array of values for the timer1 interrupt timings
unsigned int potVal; // value read from potemtiometer
int curPpm = 0; // the position in the array of timings
byte curPpmMax; // the actual number of timer steps

char pulsePin = 7; // the digital pin for sending pulses to the transmitter
char debugPin = 13; // something to watch to check things are working
char potPin = 2; // the analog pin for the potentiometer

byte loopCount = 0; // a crude substitute for delay()
int analogIn; // for reading potentiometer position


boolean testing = true;

void setup() {

  if (testing) {
    Serial.begin(9600);
    Serial.println("Starting TrainRadioPot");
  }

  // set the pin directions
  pinMode(pulsePin, OUTPUT);
  //  pinMode(debugPin, OUTPUT);

  // set the timing values
  ppm[0] = 1475; //3775; // long pulse - see notes above
  ppm[1] = 75; // short dividing pulse
  ppm[2] = 305; // loco1 ch1
  ppm[3] = 75; // short
  ppm[4] = 305; // loco2 ch2
  ppm[5] = 75; // short
  ppm[6] = 305; // loco3 ch3
  ppm[7] = 75; // short
  ppm[8] = 305; // loco4 ch4
  ppm[9] = 75; // short
  ppm[10] = 305; // loco5 ch5
  ppm[11] = 75; // short
  ppm[12] = 305; // loco6 ch6
  ppm[13] = 75; // short
  ppm[14] = 305; // loco7 ch7
  ppm[15] = 75; // short

  curPpmMax = 16; // the number of timer values
  curPpm = 0; // the starting position in the array of timings

  // setup and start timer interrupts
  // ppm is achieved by sending different delays to the timer interrupt
  noInterrupts();
  TCCR1A = 0;     // set entire TCCR1A register to 0
  TCCR1B = 0;     // same for TCCR1B
  // set compare match register to desired timer count:
  OCR1A = 1000; // It works by causing an interrupt when TCNT2 counts up to this number
  // This number will be set from the ppm array when the program is running
  digitalWrite(pulsePin, 0); // start with pin low
  // turn on CTC mode: Clear Timer on Compare
  bitSet(TCCR1B, WGM12);
  // Set CS10 and CS11 bits for 64 prescaler: 10, 12 = 1024
  bitSet(TCCR1B, CS10);
  bitSet(TCCR1B, CS11);
  bitClear(TCCR1B, CS12);
  // enable timer compare A interrupt:
  bitSet(TIMSK1, OCIE1A);
  interrupts();

}

void loop() {

  if (loopCount == 1) {
    analogIn = analogRead(potPin);
    // the reading must be converted from the range 0 - 1023 to the range 250 - 500
    //   which means dividing by 4 and adding 180 to give 305 at the centre
    potVal = (analogIn >> 2) + 180;
    //		if (potVal > 302 && potVal < 308) {
    if (potVal > 280 && potVal < 320) {
      potVal = 305; // to create an off space without jitter
    }
    //	ppm[2] = potVal;
    //  ppm[8] = potVal;// } CH4 ROL STABE
    // ppm[4] = potVal; //   CH2 PAN STABE YAW
    ppm[6] = potVal; //    CH3 TILT STABE PICH

  }


  //	loopCount = 0; // for testing - so analog read is ignored
  loopCount = loopCount + 1; // it will roll over to zero automatically
  // the purpose of loopCount is so that the pot isn't read every loop
}


// interrupt routine that is triggered when the timer counts up to the preset value
ISR(TIMER1_COMPA_vect) {
  noInterrupts();
  digitalWrite(pulsePin, !digitalRead(pulsePin)); // change the state of the pin
  OCR1A = ppm[curPpm]; // set the value for the next time interval
  curPpm = ((curPpm + 1) % curPpmMax); // move the index on
  // the modulus operator makes the index roll over to the start
  interrupts();
}

    I also found this function (not yet tested with the transmitter)

    //this programm will put out a PPM signal

//////////////////////CONFIGURATION///////////////////////////////
#define chanel_number 8  //set the number of chanels
#define default_servo_value 1500  //set the default servo value
#define PPM_FrLen 22500  //set the PPM frame length in microseconds (1ms = 1000µs)
#define PPM_PulseLen 300  //set the pulse length
#define onState 1  //set polarity: 1 is positive, 0 is negative
#define sigPin 10  //set PPM signal pin on the arduino
//////////////////////////////////////////////////////////////////


/*this array holds the servo values for the ppm signal
 change theese values in your code (usually servo values are between 1000 and 2000)*/
int ppm[chanel_number];

void setup(){  

  //initiallize default ppm values
  for(int i=0; i<chanel_number; i++){
    ppm[i]= default_servo_value;
  }

  pinMode(sigPin, OUTPUT);
  digitalWrite(sigPin, !onState);  //set the PPM signal pin to the default state (off)
}

void loop(){
  //put main code here
  ppmWrite();
}

void ppmWrite(){  //generate PPM signal
  static unsigned long lastFrLen;
  static unsigned long lastServo;
  static unsigned long lastPulse;
  static boolean PPM_run;
  static boolean pulse;
  static boolean pulseStart = true;
  static byte counter;
  static byte part = true;

  if(micros() - lastFrLen >= PPM_FrLen){  //start PPM signal after PPM_FrLen has passed
    lastFrLen = micros();
    PPM_run = true;
  }

  if(counter >= chanel_number){
    PPM_run = false;
    counter = 0;
    pulse = true;  //put out the last pulse
  }

  if(PPM_run){
    if (part){  //put out the pulse
      pulse = true;
      part = false;
      lastServo = micros();
    }
    else{  //wait till servo signal time (values from the ppm array) has passed
      if(micros() - lastServo >= ppm[counter]){
        counter++;  //do the next channel
        part = true;
      }
    }
  }

  if(pulse){
    if(pulseStart == true){  //start the pulse
      digitalWrite(sigPin, onState);
      pulseStart = false;
      lastPulse = micros();
    }
    else{  //will wait till PPM_PulseLen has passed and finish the pulse
      if(micros() - lastPulse >= PPM_PulseLen){
        digitalWrite(sigPin, !onState);
        pulse = false;
        pulseStart = true;
      }
    }
  }
}

    I really don't know how to port all of this to M5Stack.
    I'm trying to merge the first sketch with a timer interrupt sketch for esp32

    volatile int interruptCounter;
int totalInterruptCounter;

hw_timer_t * timer = NULL;
portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;

void IRAM_ATTR onTimer() {
  portENTER_CRITICAL_ISR(&timerMux);
  interruptCounter++;
  portEXIT_CRITICAL_ISR(&timerMux);

}

void setup() {

  Serial.begin(115200);

  timer = timerBegin(0, 80, true);
  timerAttachInterrupt(timer, &onTimer, true);
  //  timerAlarmWrite(timer, 1000000, true);
  timerAlarmWrite(timer,   22000, true); PER IL PPM ?? ??

  timerAlarmEnable(timer);

}

void loop() {

  if (interruptCounter > 0) {

    portENTER_CRITICAL(&timerMux);
    interruptCounter--;
    portEXIT_CRITICAL(&timerMux);

    totalInterruptCounter++;

    Serial.print("An interrupt as occurred. Total number: ");
    Serial.println(totalInterruptCounter);

  }
}

    I'm very confused....

    0
    A
     1 Reply
  • A

    Hi
    do you find a solution ? also interest by this.
    Thx

    0