Servo senkronizasyon modülü

Sumer Yamaner · 24 Mar 2015

Servo senkronizasyon modülü

Aslında kumandada yeterli kanal varsa gerçekten de gereksiz. Mikslerle gayet güzel halledebiliyoruz. Kanal sayısı yetmediğinde işe yarıyor. Yani öyle aman aman bir gerekliliği yok ama müşteriyi uyandırmamak için bunu söylemiyoruz ortalık yerde!

Sumer Yamaner · 4 Nis 2015

Servo senkronizasyon modülü

Bu proje şu an artık seri üretim olgunluğuna erişti. Tüm beta testleri yapıldı. Son sürüm plaketinde istenirse servolar ayrı bir güç kaynağından beslenebiliyorlar. İstenirse alıcıdan gelen akımla besleniyorlar. Dört servoyu merkez ve iki uç noktalarını ayarlayıp kullanabiliyoruz. Sadece bir kontrol yüzeyine birden fazla servo kullanıldığı durumlarda değil örneğin dört motorlu bir uçağın dört gaz kanalının hassas senkronizasyonunda da kullanılabilir.

Plaket bu:

[attachimg=1]

Devre bu:

[attachimg=2]

Kod da bu:

Kod:

#include <EEPROM.h>

const byte servoin = 2;
const byte servo1 = 6;
const byte servo2 = 5;
const byte servo3 = 4;
const byte servo4 = 3;
const byte mode1 = 14;
const byte mode2 = 15;
const byte decrease = 16;
const byte increase = 17;
const byte centerLED = 18;
const byte epa1LED = 12;
const byte epa2LED = 11;
const byte servo1LED = 10;
const byte servo2LED = 9;
const byte servo3LED = 8;
const byte servo4LED = 7;
const byte editstep = 1;
volatile int servoinPWM = 1500;
volatile int servo1PWM = 1500;
volatile int servo2PWM = 1500;
volatile int servo3PWM = 1500;
volatile int servo4PWM = 1500;
volatile int intcounter = 0;
volatile byte sregvalue;
long x;
volatile byte progflag = 0;
volatile byte keyflag = 0;
byte eepromerror = 0;
byte hibyte;
byte lobyte;
unsigned long timer;
int servo1cnt;
unsigned int servo1epa1;
unsigned int servo1epa2;
int servo2cnt;
unsigned int servo2epa1;
unsigned int servo2epa2;
int servo3cnt;
unsigned int servo3epa1;
unsigned int servo3epa2;
int servo4cnt;
unsigned int servo4epa1;
unsigned int servo4epa2;
volatile byte LED = 0;
byte keypress = B00111111;
int key = 0;
int key1 = 0;
int key2 = 0;
int b = 0;
const int debounce = 200;
const int bounce = 160;
void timerinit()
{
  noInterrupts();  // disable global interrupts
  TCCR2A = 0; // prescaler 256
  TCCR2B = 0;
  TCCR2B |= (0 << CS20);
  TCCR2B |= (1 << CS21);
  TCCR2B |= (1 << CS22);
  TCNT2 = 0;
  TIMSK2 |= (1 << TOIE2); // enable global interrupts
  interrupts();
}

ISR(TIMER2_OVF_vect)
{
  sregvalue = SREG;
  intcounter++;
  if (intcounter > 4)
  {
    intcounter = 0;
    if (progflag == 1)
    {
      x = servoinPWM - 1500;
      if (x < 0)
      {
        servo1PWM = 1500 + ((x * servo1epa1) / 700) + servo1cnt;
        servo2PWM = 1500 + ((x * servo2epa1) / 700) + servo2cnt;
        servo3PWM = 1500 + ((x * servo3epa1) / 700) + servo3cnt;
        servo4PWM = 1500 + ((x * servo4epa1) / 700) + servo4cnt;
      }
      else
      {
        servo1PWM = ((x * servo1epa2) / 700) + 1500 + servo1cnt;
        servo2PWM = ((x * servo2epa2) / 700) + 1500 + servo2cnt;
        servo3PWM = ((x * servo3epa2) / 700) + 1500 + servo3cnt;
        servo4PWM = ((x * servo4epa2) / 700) + 1500 + servo4cnt;
      }
    }
    servoout();
  }
  SREG = sregvalue;
}


void setup()
{
  pinMode(mode1, INPUT_PULLUP);
  pinMode(mode2, INPUT_PULLUP);
  pinMode(decrease, INPUT_PULLUP);
  pinMode(increase, INPUT_PULLUP);
  pinMode(centerLED, OUTPUT);
  pinMode(epa1LED, OUTPUT);
  pinMode(epa2LED, OUTPUT);
  pinMode(servo1LED, OUTPUT);
  pinMode(servo2LED, OUTPUT);
  pinMode(servo3LED, OUTPUT);
  pinMode(servo4LED, OUTPUT);
  pinMode(servo1, OUTPUT);
  pinMode(servo2, OUTPUT);
  pinMode(servo3, OUTPUT);
  pinMode(servo4, OUTPUT);

  if ((digitalRead(mode1) == 0) && (digitalRead(mode2) == 0))
  {
    keyflag = 1;
  }
  delay(1000);
  if ((digitalRead(mode1) == 0) && (digitalRead(mode2) == 0) && keyflag == 1)
  {
    progflag = 1;
    flashleds2();
  }
  else
  {
    flashleds();
  }

  EEPROMtest();

  if (eepromerror > 0)
  {
    while (eepromerror > 0)
    {
      digitalWrite(servo1LED, HIGH);
      digitalWrite(servo2LED, HIGH);
      digitalWrite(servo3LED, HIGH);
      digitalWrite(servo4LED, HIGH);
      delay(300);
      digitalWrite(servo1LED, LOW);
      digitalWrite(servo2LED, LOW);
      digitalWrite(servo3LED, LOW);
      digitalWrite(servo4LED, LOW);
      delay(300);
    }
  }

  EEPROMoku();
  delay(100);
  timerinit();
}

void loop()
{
  if (progflag == 0)
  {
    noInterrupts();
    digitalWrite(servo1LED, HIGH);
    digitalWrite(servo2LED, HIGH);
    digitalWrite(servo3LED, HIGH);
    digitalWrite(servo4LED, HIGH);
    normal();
  }
  else
  {
    interrupts();
    progmode();
  }
}

void normal()
{
  servoinPWM = pulseIn(servoin, HIGH, 21000);
  x = servoinPWM - 1500;
  if (x < 0)
  {
    servo1PWM = 1500 + ((x * servo1epa1) / 700) + servo1cnt;
    servo2PWM = 1500 + ((x * servo2epa1) / 700) + servo2cnt;
    servo3PWM = 1500 + ((x * servo3epa1) / 700) + servo3cnt;
    servo4PWM = 1500 + ((x * servo4epa1) / 700) + servo4cnt;
  }
  else
  {
    servo1PWM = ((x * servo1epa2) / 700) + 1500 + servo1cnt;
    servo2PWM = ((x * servo2epa2) / 700) + 1500 + servo2cnt;
    servo3PWM = ((x * servo3epa2) / 700) + 1500 + servo3cnt;
    servo4PWM = ((x * servo4epa2) / 700) + 1500 + servo4cnt;
  }
  if (servoinPWM >= 800 && servoinPWM <= 2200) servoout();
}

void progmode()
{
  int servosira = 1;
  int islevsira = 1;
  int pressedkey = 0; // 0: Key yok, 1: Mode1(servo), 2: Mode2(işlev), 3: Decrease, 4: Increase, 5: Exit

  while (pressedkey < 5)
  {
    noInterrupts();
    switch (islevsira)
    {
      case 1:
        servo1PWM = 1500 + servo1cnt;
        servo2PWM = 1500 + servo2cnt;
        servo3PWM = 1500 + servo3cnt;
        servo4PWM = 1500 + servo4cnt;
        servoinPWM = 1500;
        break;
      case 2:
        servo1PWM = 1500 + servo1cnt - servo1epa1;
        servo2PWM = 1500 + servo2cnt - servo2epa1;
        servo3PWM = 1500 + servo3cnt - servo3epa1;
        servo4PWM = 1500 + servo4cnt - servo4epa1;
        servoinPWM = 1000;
        break;
      case 3:
        servo1PWM = 1500 + servo1cnt + servo1epa2;
        servo2PWM = 1500 + servo2cnt + servo2epa2;
        servo3PWM = 1500 + servo3cnt + servo3epa2;
        servo4PWM = 1500 + servo4cnt + servo4epa2;
        servoinPWM = 2000;
        break;
    }
    interrupts();
    pressedkey = button();
    switch (pressedkey)
    {
      case 0:
        break;
      case 1:
        servosira++;
        if (servosira > 4) servosira = 1;
        break;
      case 2:
        islevsira++;
        if (islevsira > 3) islevsira = 1;
        break;
      case 3:
        if (servosira == 1)
        {
          switch (islevsira)
          {
            case 1:
              servo1cnt = servo1cnt - editstep;
              if (servo1cnt < (-200)) servo1cnt = -200;
              break;
            case 2:
              servo1epa1 = servo1epa1 - editstep;
              if (servo1epa1 < 1) servo1epa1 = 1;
              break;
            case 3:
              servo1epa2 = servo1epa2 - editstep;
              if (servo1epa2 < 1) servo1epa2 = 1;
              break;
          }
        }
        if (servosira == 2)
        {
          switch (islevsira)
          {
            case 1:
              servo2cnt = servo2cnt - editstep;
              if (servo2cnt < (-200)) servo2cnt = -200;
              break;
            case 2:
              servo2epa1 = servo2epa1 - editstep;
              if (servo2epa1 < 1) servo2epa1 = 1;
              break;
            case 3:
              servo2epa2 = servo2epa2 - editstep;
              if (servo2epa2 < 1) servo2epa2 = 1;
              break;
          }
        }
        if (servosira == 3)
        {
          switch (islevsira)
          {
            case 1:
              servo3cnt = servo3cnt - editstep;
              if (servo3cnt < (-200)) servo3cnt = -200;
              break;
            case 2:
              servo3epa1 = servo3epa1 - editstep;
              if (servo3epa1 < 1) servo3epa1 = 1;
              break;
            case 3:
              servo3epa2 = servo3epa2 - editstep;
              if (servo3epa2 < 1) servo3epa2 = 1;
              break;
          }
        }
        if (servosira == 4)
        {
          switch (islevsira)
          {
            case 1:
              servo4cnt = servo4cnt - editstep;
              if (servo4cnt < (-200)) servo4cnt = -200;
              break;
            case 2:
              servo4epa1 = servo4epa1 - editstep;
              if (servo4epa1 < 1) servo4epa1 = 1;
              break;
            case 3:
              servo4epa2 = servo4epa2 - editstep;
              if (servo4epa2 < 1) servo4epa2 = 1;
              break;
          }
        }
        break;
      case 4:
        if (servosira == 1)
        {
          switch (islevsira)
          {
            case 1:
              servo1cnt = servo1cnt + editstep;
              if (servo1cnt > 200) servo1cnt = 200;
              break;
            case 2:
              servo1epa1 = servo1epa1 + editstep;
              if (servo1epa1 > 700) servo1epa1 = 700;
              break;
            case 3:
              servo1epa2 = servo1epa2 + editstep;
              if (servo1epa2 > 700) servo1epa2 = 700;
              break;
          }
        }
        if (servosira == 2)
        {
          switch (islevsira)
          {
            case 1:
              servo2cnt = servo2cnt + editstep;
              if (servo2cnt > 200) servo2cnt = 200;
              break;
            case 2:
              servo2epa1 = servo2epa1 + editstep;
              if (servo2epa1 > 700) servo2epa1 = 700;
              break;
            case 3:
              servo2epa2 = servo2epa2 + editstep;
              if (servo2epa2 > 700) servo2epa2 = 700;
              break;
          }

        }
        if (servosira == 3)
        {
          switch (islevsira)
          {
            case 1:
              servo3cnt = servo3cnt + editstep;
              if (servo3cnt > 200) servo3cnt = 200;
              break;
            case 2:
              servo3epa1 = servo3epa1 + editstep;
              if (servo3epa1 > 700) servo3epa1 = 700;
              break;
            case 3:
              servo3epa2 = servo3epa2 + editstep;
              if (servo3epa2 > 700) servo3epa2 = 700;
              break;
          }
        }
        if (servosira == 4)
        {
          switch (islevsira)
          {
            case 1:
              servo4cnt = servo4cnt + editstep;
              if (servo4cnt > 200) servo4cnt = 200;
              break;
            case 2:
              servo4epa1 = servo4epa1 + editstep;
              if (servo4epa1 > 700) servo4epa1 = 700;
              break;
            case 3:
              servo4epa2 = servo4epa2 + editstep;
              if (servo4epa2 > 700) servo4epa2 = 700;
              break;
          }
        }

        break;
    }


    if (pressedkey > 0);
    {
      digitalWrite(centerLED, LOW);
      digitalWrite(epa1LED, LOW);
      digitalWrite(epa2LED, LOW);
      digitalWrite(servo1LED, LOW);
      digitalWrite(servo2LED, LOW);
      digitalWrite(servo3LED, LOW);
      digitalWrite(servo4LED, LOW);

      switch (servosira)
      {
        case 1:
          digitalWrite(servo1LED, HIGH);
          break;
        case 2:
          digitalWrite(servo2LED, HIGH);
          break;
        case 3:
          digitalWrite(servo3LED, HIGH);
          break;
        case 4:
          digitalWrite(servo4LED, HIGH);
          break;
      }

      switch (islevsira)
      {
        case 1:
          digitalWrite(centerLED, HIGH);
          break;
        case 2:
          digitalWrite(epa1LED, HIGH);
          break;
        case 3:
          digitalWrite(epa2LED, HIGH);
          break;
      }
    }

  }
  EEPROMyaz();
/*
  digitalWrite(centerLED, LOW);
  digitalWrite(epa1LED, LOW);
  digitalWrite(epa2LED, LOW);
  for (int n = 0; n < 5; n++)
  {
    digitalWrite(servo1LED, HIGH);
    digitalWrite(servo2LED, HIGH);
    digitalWrite(servo3LED, HIGH);
    digitalWrite(servo4LED, HIGH);
    delay(100);
    digitalWrite(servo1LED, LOW);
    digitalWrite(servo2LED, LOW);
    digitalWrite(servo3LED, LOW);
    digitalWrite(servo4LED, LOW);
    delay(100);
  }
*/
  flashleds2();
  progflag = 0;
}

void EEPROMoku()
{
  noInterrupts();
  servo1cnt = EEPROM.read(1) + 256 * EEPROM.read(0) - 2000;
  servo1epa1 = EEPROM.read(3) + 256 * EEPROM.read(2);
  servo1epa2 = EEPROM.read(5) + 256 * EEPROM.read(4);
  servo2cnt = EEPROM.read(7) + 256 * EEPROM.read(6) - 2000;
  servo2epa1 = EEPROM.read(9) + 256 * EEPROM.read(:coolxf:;
  servo2epa2 = EEPROM.read(11) + 256 * EEPROM.read(10);
  servo3cnt = EEPROM.read(13) + 256 * EEPROM.read(12) - 2000;
  servo3epa1 = EEPROM.read(15) + 256 * EEPROM.read(14);
  servo3epa2 = EEPROM.read(17) + 256 * EEPROM.read(16);
  servo4cnt = EEPROM.read(19) + 256 * EEPROM.read(1:coolxf: - 2000;
  servo4epa1 = EEPROM.read(21) + 256 * EEPROM.read(20);
  servo4epa2 = EEPROM.read(23) + 256 * EEPROM.read(22);
  interrupts();
}

void EEPROMyaz()
{
  noInterrupts();
  hibyte = (servo1cnt + 2000) / 256;
  lobyte = (servo1cnt + 2000) - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo1epa1 / 256;
  lobyte = servo1epa1 - 256 * hibyte;
  EEPROM.write(2, hibyte);
  EEPROM.write(3, lobyte);

  hibyte = servo1epa2 / 256;
  lobyte = servo1epa2 - 256 * hibyte;
  EEPROM.write(4, hibyte);
  EEPROM.write(5, lobyte);

  hibyte = (servo2cnt + 2000) / 256;
  lobyte = (servo2cnt + 2000) - 256 * hibyte;
  EEPROM.write(6, hibyte);
  EEPROM.write(7, lobyte);

  hibyte = servo2epa1 / 256;
  lobyte = servo2epa1 - 256 * hibyte;
  EEPROM.write(8, hibyte);
  EEPROM.write(9, lobyte);

  hibyte = servo2epa2 / 256;
  lobyte = servo2epa2 - 256 * hibyte;
  EEPROM.write(10, hibyte);
  EEPROM.write(11, lobyte);

  hibyte = (servo3cnt + 2000) / 256;
  lobyte = (servo3cnt + 2000) - 256 * hibyte;
  EEPROM.write(12, hibyte);
  EEPROM.write(13, lobyte);

  hibyte = servo3epa1 / 256;
  lobyte = servo3epa1 - 256 * hibyte;
  EEPROM.write(14, hibyte);
  EEPROM.write(15, lobyte);

  hibyte = servo3epa2 / 256;
  lobyte = servo3epa2 - 256 * hibyte;
  EEPROM.write(16, hibyte);
  EEPROM.write(17, lobyte);

  hibyte = (servo4cnt + 2000) / 256;
  lobyte = (servo4cnt + 2000) - 256 * hibyte;
  EEPROM.write(18, hibyte);
  EEPROM.write(19, lobyte);

  hibyte = servo4epa1 / 256;
  lobyte = servo4epa1 - 256 * hibyte;
  EEPROM.write(20, hibyte);
  EEPROM.write(21, lobyte);

  hibyte = servo4epa2 / 256;
  lobyte = servo4epa2 - 256 * hibyte;
  EEPROM.write(22, hibyte);
  EEPROM.write(23, lobyte);
  interrupts();
}

void EEPROMtest()
{
  eepromerror = 0;
  unsigned long b = 0;
  unsigned int temp;
  for (int i = 0; i < 18; i++)
  {
    b = b + EEPROM.read(i);
  }
  if (b == 4590)
  {
    temp = EEPROM.read(0);
    EEPROM.write(0, 0);
    if (EEPROM.read(0) != 0)
    {
      eepromerror = 1;
    }
    EEPROM.write(0, temp);
  }
}

int button() // 0: Geçerli tuş yok. 1: Mode1. 2: Mode2. 3: Decrease. 4: Increase. 5: Done.
{
  key1 = buttonbas();
  key2 = debouncebutton();
  if ((key1 == key2) && ((key1 * key2) != 0))
  {
    return key1;
  }
  return 0;
}

int buttonbas()
{
  keypress = PINC & B00001111;
  for (int n = 0; n < 10; n++)
  {
    keypress &= PINC;
  }
  if (keypress == B00001100) return 5;
  if (keypress == B00001110) return 1;
  if (keypress == B00001101) return 2;
  if (keypress == B00001011) return 3;
  if (keypress == B00000111) return 4;
  return 0;
}

int debouncebutton() //Buraya gelirken key1 değişkeni basıldığı belirlenen butonu içeriyor. Yani 0 - 5 arası bir değer.
{
  if (key1 == 0) return key1;
  b = 0; //Sayaç sıfırlanıyor
  for (int n = 0; n < debounce; n++)
  {
    key = buttonbas();
    if (key == key1) b++;
    else if (key != 0) return 0;
  }
  if (b < bounce) return 0;
  if (key1 > 2 && key1 < 5)
  {
    delay(20);
  }
  else
  {
    while (buttonbas() != 0)
    {
    }
  }
  return key1;
}


void flashleds()
{
  digitalWrite(centerLED, HIGH);
  delay(200);
  digitalWrite(centerLED, LOW);

  digitalWrite(epa1LED, HIGH);
  delay(200);
  digitalWrite(epa1LED, LOW);

  digitalWrite(epa2LED, HIGH);
  delay(200);
  digitalWrite(epa2LED, LOW);

  digitalWrite(servo1LED, HIGH);
  delay(200);
  digitalWrite(servo1LED, LOW);

  digitalWrite(servo2LED, HIGH);
  delay(200);
  digitalWrite(servo2LED, LOW);

  digitalWrite(servo3LED, HIGH);
  delay(200);
  digitalWrite(servo3LED, LOW);

  digitalWrite(servo4LED, HIGH);
  delay(200);
  digitalWrite(servo4LED, LOW);

}

void flashleds2()
{
  for (int n = 0; n < 5; n++)
  {
    digitalWrite(centerLED, HIGH);
    digitalWrite(epa1LED, HIGH);
    digitalWrite(epa2LED, HIGH);
    digitalWrite(servo1LED, HIGH);
    digitalWrite(servo2LED, HIGH);
    digitalWrite(servo3LED, HIGH);
    digitalWrite(servo4LED, HIGH);
    delay(200);
    digitalWrite(centerLED, LOW);
    digitalWrite(epa1LED, LOW);
    digitalWrite(epa2LED, LOW);
    digitalWrite(servo1LED, LOW);
    digitalWrite(servo2LED, LOW);
    digitalWrite(servo3LED, LOW);
    digitalWrite(servo4LED, LOW);
    delay(200);
  }
}

void servoout()
{
  digitalWrite(servo1, HIGH);
  delayMicroseconds(servo1PWM);
  digitalWrite(servo1, LOW);

  digitalWrite(servo2, HIGH);
  delayMicroseconds(servo2PWM);
  digitalWrite(servo2, LOW);

  digitalWrite(servo3, HIGH);
  delayMicroseconds(servo3PWM);
  digitalWrite(servo3, LOW);

  digitalWrite(servo4, HIGH);
  delayMicroseconds(servo4PWM);
  digitalWrite(servo4, LOW);
}

Mehmet Kucuksari · 4 Nis 2015

Servo senkronizasyon modülü

Böylece bir proje daha basarili bir sekilde hayata gecmis oldu. Ellerine sağlık abi :halay:

Sent from my iPhone using Tapatalk

Sumer Yamaner · 5 Nis 2015

Servo senkronizasyon modülü

Hayata geçse de sonlanmıyor hiç. Bu akşam bir de buton kombinasyonları ile full data reset ekledim.

Daha güzel oldu.

Sumer Yamaner · 15 Ara 2018

Üçbuçuk yıl olmuş... Geriye baktığımda güya bitti dediğim projenin ne kadar acemice olduğunu görebiliyorum.
Bir arkadaşımın talebi doğrultusunda bu projeyi yeniden ele alıp çok daha düzgün bir devre oluşturdum. Kodu baştan sona tekrar yazdığımı söylememe gerek yoktur herhalde. Zira önceki kod da devre tasarımı gibi acemiceymiş!

İki ayrı modelimiz var artık. Birisi üç diğeri dört kanallı...

Bu RESMİ görmek için izniniz yok. Giriş yap veya üye ol

Mehmet Kucuksari · 15 Ara 2018

Sumer Yamaner' Alıntı:
Üçbuçuk yıl olmuş

Zaman ne çabuk ve hızlı geçiyor

Ömer Erkan · 15 Ara 2018

Firmalar da bunun için zaten "Version I don't know what" (sürüm bilmemkaç) çıkarmıyorlar mı?...

Sumer Yamaner · 17 Eki 2019

Yeni bir versiyon I don't know what geldi. Artık ekranlı bir senkronizasyon devremiz var ve çözünürlüğü 1 mikrosaniyeden 0.5 mikrosaniyeye yükseltildi.

Bu RESMİ görmek için izniniz yok. Giriş yap veya üye ol

Mehmet Kucuksari · 17 Eki 2019

Sumer Yamaner' Alıntı:
Yeni bir versiyon I don't know what geldi. Artık ekranlı bir senkronizasyon devremiz var ve çözünürlüğü 1 mikrosaniyeden 0.5 mikrosaniyeye yükseltildi.

Ekran yakışıyor abi :thumbup:

Sumer Yamaner · 17 Eki 2019

Mehmet Kucuksari' Alıntı:
Ekran yakışıyor abi

Yaaa güzele her şey yakışır işte...

Mustafa YILDIRIM33 · 26 Şub 2020

Sumer Bey merhaba,
Öncelikle çok emek verilmiş ve güzel bir iş çıkartılmış, tebrik ederim.
Servo kontrol ile alakalı olarak bir sorum olacaktı.
"Sessizce takip ettiğiniz konuda

ki proje ile alakalı."

F22 raptorda kullanılmak üzere yapmaya çalıştığımız kumanda da, servoların kontrolünde yaşadığımız bir problem.
Bildiğiniz gibi f22 lerde arka iki kanat üzerinde bulunan servolar kalkış esnasında beraber (senkron) hareket ediyor ama sağa yada sola dönüşte ters hareket ediyorlar.

Bu hareketileri, arduino üzerinde nasıl bir kod ile çalıştırabiliriz?

Kumanda ve alıcı kodları;

Kumanda,

Kod:

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

const uint64_t my_radio_pipe = 0xE8E8F0F0E1LL; //Remember that this code should be the same for the receiver

RF24 radio(9, 10);  //Set CE and CSN pins

// The sizeof this struct should not exceed 32 bytes
struct Data_to_be_sent {
  byte ch1;
  byte ch2;
  byte ch3;
  byte ch4;
  byte ch5;
  byte ch6;
  byte ch7;
};

//Create a variable with the structure above and name it sent_data
Data_to_be_sent sent_data;



void setup()
{
  radio.begin();
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.openWritingPipe(my_radio_pipe);

  //Reset each channel value
  sent_data.ch1 = 127;
  sent_data.ch2 = 127;
  sent_data.ch3 = 127;
  sent_data.ch4 = 127;
  sent_data.ch5 = 0;
  sent_data.ch6 = 0;
  sent_data.ch7 = 0;
}

/**************************************************/


void loop()
{
  /*If your channel is reversed, just swap 0 to 255 by 255 to 0 below
  EXAMPLE:
  Normal:    data.ch1 = map( analogRead(A0), 0, 1024, 0, 255);
  Reversed:  data.ch1 = map( analogRead(A0), 0, 1024, 255, 0);  */

  sent_data.ch1 = map( analogRead(A0), 0, 1024, 255, 0);
  sent_data.ch2 = map( analogRead(A1), 0, 1024, 0, 255);
  sent_data.ch3 = map( analogRead(A2), 0, 1024, 0, 255);
  sent_data.ch4 = map( analogRead(A3), 0, 1024, 0, 255);
  sent_data.ch5 = digitalRead(2);
  sent_data.ch6 = digitalRead(3);
  sent_data.ch7 = map( analogRead(A4), 0, 1024, 0, 255);

  radio.write(&sent_data, sizeof(Data_to_be_sent));
}

Alıcı,

Kod:

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Servo.h>  //To create PWM signals we need this lybrary

const uint64_t pipeIn = 0xE8E8F0F0E1LL;     //Remember that this code is the same as in the transmitter
RF24 radio(9, 10);  //CSN and CE pins

// The sizeof this struct should not exceed 32 bytes
struct Received_data {
  byte ch1;
  byte ch2;
  byte ch3;
  byte ch4;
  byte ch5;
  byte ch6;
  byte ch7;
};

Received_data received_data;

Servo channel_1;
Servo channel_2;
Servo channel_3;
Servo channel_4;
Servo channel_5;
Servo channel_6;
Servo channel_7;

int ch1_value = 0;
int ch2_value = 0;
int ch3_value = 0;
int ch4_value = 0;
int ch5_value = 0;
int ch6_value = 0;
int ch7_value = 0;

void reset_the_Data()
{
  // 'safe' values to use when NO radio input is detected
  received_data.ch1 = 0;      //Throttle (channel 1) to 0
  received_data.ch2 = 127;
  received_data.ch3 = 127;
  received_data.ch4 = 127;
  received_data.ch5 = 0;
  received_data.ch6 = 0;
  received_data.ch7 = 0;
}



/**************************************************/

void setup()
{
  //Attach the servo signal on pins from D2 to D8
  channel_1.attach(2);
  channel_2.attach(3);
  channel_3.attach(4);
  channel_4.attach(5);
  channel_5.attach(6);
  channel_6.attach(7);
  channel_7.attach(8);

  //We reset the received values
  reset_the_Data();

  //Once again, begin and radio configuration
  radio.begin();
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.openReadingPipe(1,pipeIn);

  //We start the radio comunication
  radio.startListening();

}

/**************************************************/

unsigned long lastRecvTime = 0;

//We create the function that will read the data each certain time
void receive_the_data()
{
  while ( radio.available() ) {
  radio.read(&received_data, sizeof(Received_data));
  lastRecvTime = millis(); //Here we receive the data
}
}

/**************************************************/

void loop()
{
  //Receive the radio data
  receive_the_data();

//////////This small if will reset the data if signal is lost for 1 sec.
/////////////////////////////////////////////////////////////////////////
  unsigned long now = millis();
  if ( now - lastRecvTime > 1000 ) {
    // signal lost?
    reset_the_Data();
    //Go up and change the initial values if you want depending on
    //your aplications. Put 0 for throttle in case of drones so it won't
    //fly away
  }


  ch1_value = map(received_data.ch1,255,0,1000,2000);
  ch2_value = map(received_data.ch2,0,255,1000,2000);
  ch3_value = map(received_data.ch3,0,255,1000,2000);
  ch4_value = map(received_data.ch4,0,255,1000,2000);
  ch5_value = map(received_data.ch5,0,1,1000,2000);
  ch6_value = map(received_data.ch6,0,1,1000,2000);
  ch7_value = map(received_data.ch7,0,255,1000,2000);

  //Creathe the PWM signals
  channel_1.writeMicroseconds(ch1_value);
  channel_2.writeMicroseconds(ch2_value);
  channel_3.writeMicroseconds(ch3_value);
  channel_4.writeMicroseconds(ch4_value);
  channel_5.writeMicroseconds(ch5_value);
  channel_6.writeMicroseconds(ch6_value);
  channel_7.writeMicroseconds(ch7_value);


}//Loop end

Sumer Yamaner · 26 Şub 2020

Mustafa YILDIRIM33' Alıntı:
Sumer Bey merhaba,
Öncelikle çok emek verilmiş ve güzel bir iş çıkartılmış, tebrik ederim.
Servo kontrol ile alakalı olarak bir sorum olacaktı.
"Sessizce takip ettiğiniz konuda ki proje ile alakalı."

F22 raptorda kullanılmak üzere yapmaya çalıştığımız kumanda da, servoların kontrolünde yaşadığımız bir problem.
Bildiğiniz gibi f22 lerde arka iki kanat üzerinde bulunan servolar kalkış esnasında beraber (senkron) hareket ediyor ama sağa yada sola dönüşte ters hareket ediyorlar.

Bu hareketileri, arduino üzerinde nasıl bir kod ile çalıştırabiliriz?

Kodunuza göz gezdirdim. Fazlaca hazır kütüphane kullanıldığı için bir şey söylemek zor ama görebildiğim kadarıyla 20 mS frame tutturmak için bir önlem alınmamış gibi. Ayrıca "map" işlevlerindeki 1024'ler bence 1023 olmalıydı.
Sorduğunuz işleve "V Tail Mixing" deniyor. Elevatör stiğini ve aileron stiğini belirli oranda karıştırıyorsunuz. Servolardan birisi birinci kanala diğeri ikinci kanala takılıyor. Elevatör stiği her iki servoyu aynı yönde hareket ettiriyor, aileron stiği ters yönlerde hareket ettiriyor.
Örneğin...

stick1 = analogRead(STICK1);
stick2 = analogRead(STICK2);

Görebildiğim kadarıyla servo komutlarınız 8 bit çözünürlükte yani 0 ile 255 arası bir değer gönderiyorsunuz. (Standart kumandalarda bu çözünürlük 1024, yeni modellerde 4096).
Bu durumda "map" işlevi gereksiz. Basitçe bitwise shift ya da bölme işlemi daha uygun.
O halde okumayı şu şekilde yapalım:

stick1 = analogRead(STICK1) / 4;
stick2 = analogRead(STICK2) / 4);

Yaklaşık şöyle bir kod ilk aşamada iş görebilir.
servo1 = 128 + (stick1 - stick2) / 2;
servo2 = (stick1 + stick2) / 2;

Daha detaylı bir kod için akşam arşivime bakmam lazım.

Mustafa YILDIRIM33 · 26 Şub 2020

Çok teşekkür ederim vaktinizi ayırıp yazdığınız için.

YÖNETİM tarafından açılan Konu Bilgilendirmesi

Sabırsızlıkla bekliyoum.
(Tam olarak hangi satıra eklemem gerektiğinide aktarabilirseniz çok memnun olurum)

Sumer Yamaner · 26 Şub 2020

Mustafa YILDIRIM33' Alıntı:
Çok teşekkür ederim vaktinizi ayırıp yazdığınız için.

YÖNETİM tarafından açılan Konu Bilgilendirmesi

Bu konu YÖNETİM tarafından aşağıdaki mesaj taşınarak açılmıştır.
Daha detaylı bir kod için akşam arşivime bakmam lazım.

Sabırsızlıkla bekliyoum.
(Tam olarak hangi satıra eklemem gerektiğinide aktarabilirseniz çok memnun olurum)

Tam olarak hangi satıra ekleneceğini söyleyebilmem için sizin kodunuzu anlamam lazım. Sizin kodunuzu anlayabilmem için onu bana açıklamanız lazım. Çünkü kodu yazarken neredeyse hiç "remark" kullanmamışsınız. Ama kendiniz yazdığınız için düşünce tarzınızı ve çalışma mantığını anlatabilirsiniz. Kodunuzu anladıktan sonra belki nereye nasıl satırlar ekleneceğini söyleyebilirim. Burada "belki" çok önemli çünkü bu iş için zaman ayırmalıyım ve bu konuda söz vermem imkansız.

Sumer Yamaner · 26 Şub 2020

Benim V-Tail mixer kodumun temeli şu:

Kod:

void loop()
{
  elev_signal = pulseIn(elevator, HIGH, 25000); // Elevatör sinyal girişini oku
  rudd_signal = pulseIn(rudder, HIGH, 25000); // Rudder sinyal girişini oku
  elev_signal = elev_signal - 1000; // 1000 - 2000 mikrosaniye sinyali
  rudd_signal = rudd_signal - 1000; // 0 - 1000 mikrosaniyeye dönüştür
  elev_signal = elev_signal / 2; // Her iki sinyali de ikiye böl
  rudd_signal = rudd_signal / 2;
  out_1 = elev_signal + rudd_signal + 1000; // Bir servo çıkışını hesapla
  constrain(out_1, 1000, 2000); // Ne olur ne olmaz diye sinyali sınırla
  out_2 = rudd_signal - elev_signal + 1500; // Diğer servo sinyalini hesapla
  constrain(out_2, 800, 2200); // Ne olur ne olmaz diye sinyali sınırla
  Serial.print("OUT2 = "); // Bu tamamen test amaçlı, normal çalışmada olmayacak
  Serial.println(out_2); // Bu tamamen test amaçlı, normal çalışmada olmayacak
  servoout(); // Servo sinyallerini üret
}

Tabii bu kod alıcıdan gelen iki kanal verisini miksliyor. Daha önce yazdığım satırlar ise bunu vericide yapmak için.

Ara

Servo senkronizasyon modülü

Sumer Yamaner

Moderator

Sumer Yamaner

Moderator

Ekli dosyalar

Mehmet Kucuksari

Administrator

Sumer Yamaner

Moderator

Sumer Yamaner

Moderator

Mehmet Kucuksari

Administrator

Ömer Erkan

RcFanatik

Sumer Yamaner

Moderator

Mehmet Kucuksari

Administrator

Sumer Yamaner

Moderator

Mustafa YILDIRIM33

Çalışkan Uye

Sumer Yamaner

Moderator

Mustafa YILDIRIM33

Çalışkan Uye

Sumer Yamaner

Moderator

Sumer Yamaner

Moderator

Hitec hs-225bb servo muadili servo öneriniz

Servo sorunu

Full metal dişli olan servo motor önerisi

Servo motordan ses geliyor çalışmıyor

Satılık Servo senkronizasyon modülü