Servo senkronizasyon modülü

[Sumer Yamaner]

Servo senkronizasyon modülü

servo1PWM = ((x * servo1epa1) / 700) + 1500 + servo1cnt;

Yukarıdaki olmaz mı ?

Hiç olmaz mı... Fıstıklar gibi de olur! Teşekkür ederim...

 

[Sumer Yamaner]

Eve giderken epey bir düşündüm. Şimdi bu alet uçak kırım geçirmediği ya da ciddi bir mekanik değişiklik yapılmadığı veya servo değiştirilmediği sürece programlama gerektirmeyecek. Diğer yandan EEPROM yazma ömrü kısıtlı. Acaba diyorum bir tane "master" aletle yapılacak ayar sonrası elde edilen ve normalde EEPROM'a kaydedilmesi planlanan değerleri doğrudan sabit olarak programa gömüp ayrı bir Arduino Nano programlayıp uçakta onu kullansak... Mantıklı olmaz mı?

 

[Sumer Yamaner]

Zafer kardeşimin önerisi ile kod daha da şıklaştı (ufak bir mantık hatasını düzelttim. X < 0 ise değeri 1500'e eklemeyip 1500'den çıkarmamız gerekiyor).

servoinPWM = pulseIn(servoin, HIGH, 21000); // Alıcıdan gelen sinyali okuyoruz (µS)
x = servoinPWM – 1500; // x – 700 ile + 700 arasında bir değer alıyor
if(x < 0)
{
servo1PWM = 1500 - ((x * servo1epa1) / 700) + servo1cnt; //Servo1 için çıkış değeri oluşturuluyor
servo2PWM = 1500 - ((x * servo2epa1) / 700) + servo2cnt; //Servo2 için çıkış değeri oluşturuluyor
servo3PWM = 1500 - ((x * servo3epa1) / 700) + servo3cnt; //Servo3 için çıkış değeri oluşturuluyor
}
else
{
servo1PWM = ((x * servo1epa2) / 700) + 1500 + servo1cnt; //Servo1 için çıkış değeri oluşturuluyor
servo2PWM = ((x * servo2epa2) / 700) + 1500 + servo2cnt; //Servo2 için çıkış değeri oluşturuluyor
servo3PWM = ((x * servo3epa2) / 700) + 1500 + servo3cnt; //Servo3 için çıkış değeri oluşturuluyor
}

 

[Sumer Yamaner]

560 satırı bulduk kodda. Tek bir işlev dışında tümü hazır. Tuşların değerlendirilmesi için yardım istiyorum. Kafam tamamen durdu artık.

Toplam dört tuş var ve active LOW olarak çalışıyorlar.
Şöyle bir altprogram tasarladım.

int keypress() // 0: Geçerli tuş yok. 1: Mode1. 2: Mode2. 3: Decrease. 4: Increase. 5: Done.
{


}


Tuşları okuyacak. Sadece bir tuşa basılmasına izin verecek. Tuşa baslımadı ya da geçersiz çoklu tuşa basıldı ise 0 döndürecek.
Mode1 (Servo Select) tuşu için 1
Mode2 (Function Select) tuşu için 2
Decrease tuşu için 3
Increase tuşu için 4 döndürecek.
Mode1 ve Mode2 tuşlarına birlikte iki saniye basıldığında ise programanın bittiğini gösteren 5 döndürecek.

Tuşlar donanımsal olarak şu şekilde tanımlı:
Mode1 buton giriş 14 A0 mode1 const byte Active LOW, Internal pullup
Mode2 buton giriş 15 A1 mode2 const byte Active LOW, Internal pullup
Increase buton giriş 16 A2 increase const byte Active LOW, Internal pullup
Decrease buton giriş 17 A3 decrease const byte Active LOW, Internal pullup

Haydi Zafer Şahin, bunu sen çözersin!

 

[Sumer Yamaner]

Merak eden olursa kodun son hali bu...

#include <MsTimer2.h>
#include <EEPROM.h>

const byte servoin = 3;
const byte servo1 = 6;
const byte servo2 = 5;
const byte servo3 = 4;
const byte mode1 = 14;
const byte mode2 = 15;
const byte increase = 16;
const byte decrease = 17;
const byte centerLED = 12;
const byte epa1LED = 11;
const byte epa2LED = 10;
const byte servo1LED = 9;
const byte servo2LED = 8;
const byte servo3LED = 7;

volatile unsigned int servoinPWM = 1500;
volatile unsigned int servo1PWM = 1500;
volatile unsigned int servo2PWM = 1500;
volatile unsigned int servo3PWM = 1500;

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;

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

  if (digitalRead(mode1) != digitalRead(mode2))
  {
    keyflag = 1;
  }
  delay(100);
  if (digitalRead(mode1) != digitalRead(mode2))
  {
    progflag = 1;
    keyflag = 0;
  }

  EEPROMtest();

  if (eepromerror > 0) // EEPROM hatasında servo LED'lerini yakıp söndürerek beklemede kalıyoruz. Programa girmiyoruz. Güç kesilene kadar böyle devam.
  {
    while (eepromerror > 0)
    {
      digitalWrite(servo1, HIGH);
      digitalWrite(servo2, HIGH);
      digitalWrite(servo3, HIGH);
      delay(300);
      digitalWrite(servo1, LOW);
      digitalWrite(servo2, LOW);
      digitalWrite(servo3, LOW);
      delay(300);
    }
  }

  EEPROMoku();
  if (progflag == 0)
  {
    MsTimer2::set(20, servoout);
    MsTimer2::start();
  }
}

void loop()
{
  if (progflag == 0)
  {
    normal();
  }
  else
  {
    progmode();
  }
}

void normal() // Programlama modunda değilsek loop()'tan sürekli bu işlev çağrılıyor
{
  servoinPWM = pulseIn(servoin, HIGH, 21000); //Alıcıdan sinyali mikrosaniye olarak okuyoruz
  x = servoinPWM - 1500; // x -700 ile + 700 arasında bir değer alıyor
  if (x < 0)
  {
    servo1PWM = 1500 - ((x * servo1epa1) / 700) + servo1cnt; //Servo1 için çıkış değeri oluşturuluyor
    servo2PWM = 1500 - ((x * servo2epa1) / 700) + servo2cnt; //Servo2 için çıkış değeri oluşturuluyor
    servo3PWM = 1500 - ((x * servo3epa1) / 700) + servo3cnt; //Servo3 için çıkış değeri oluşturuluyor
  }
  else
  {
    servo1PWM = ((x * servo1epa2) / 700) + 1500 + servo1cnt; //Servo1 için çıkış değeri oluşturuluyor
    servo2PWM = ((x * servo2epa2) / 700) + 1500 + servo2cnt; //Servo2 için çıkış değeri oluşturuluyor
    servo3PWM = ((x * servo3epa2) / 700) + 1500 + servo3cnt; //Servo3 için çıkış değeri oluşturuluyor
  }
}

void progmode() // Programlama modunda isek loop()'tan sürekli bu çağrılıyor
{
  int servosira = 1; // 1 No'lu servo ile başlıyoruz
  int islevsira = 1; // Center modu ile başlıyoruz. 1: Center, 2: Alt EPA, 3: Üst EPA
  int pressedkey = 0; // 0: Key yok, 1: Mode1(servo), 2: Mode2(işlev), 3: Decrease, 4: Increase, 5: Exit

  while (pressedkey < 5)
  {
    switch (islevsira)
    {
      case 1:
        servo1PWM = 1500 + servo1cnt;
        servo2PWM = 1500 + servo2cnt;
        servo3PWM = 1500 + servo3cnt;
        break;
      case 2:
        servo1PWM = 1500 + servo1cnt - servo1epa1;
        servo2PWM = 1500 + servo2cnt - servo2epa1;
        servo3PWM = 1500 + servo3cnt - servo3epa1;
        break;
      case 3:
        servo1PWM = 1500 + servo1cnt - servo1epa2;
        servo2PWM = 1500 + servo2cnt - servo2epa2;
        servo3PWM = 1500 + servo3cnt - servo3epa2;
        break;
    }

    switch (servosira)
    {
      case 1:
        servo1out();
        break;
      case 2:
        servo2out();
        break;
      case 3:
        servo3out();
        break;
    }
    pressedkey = keypress();
    switch (pressedkey)
    {
      case 1:
        servosira++;
        if (servosira > 3)
        {
          servosira = 1;
        }
        break;
      case 2:
        islevsira++;
        if (islevsira > 3)
        {
          islevsira = 1;
        }
        break;
      case 3: // Burada o an seçili olan parametreyi bir azaltacağız. Range check yapıp düzelteceğiz.
        if (servosira == 1)
        {
          if (islevsira == 1)
          {
            servo1cnt--;
            if (servo1cnt < (-700))
            {
              servo1cnt = -700;
            }
          }
          if (islevsira == 2)
          {
            servo1epa1--;
            if (servo1epa1 < 1)
            {
              servo1epa1 = 1;
            }
          }
          if (islevsira == 2)
          {
            servo1epa2--;
            if (servo1epa2 < 1)
            {
              servo1epa2 = 1;
            }
          }
        }
        if (servosira == 2)
        {
          if (islevsira == 1)
          {
            servo1cnt--;
            if (servo2cnt < (-700))
            {
              servo2cnt = -700;
            }
          }
          if (islevsira == 2)
          {
            servo2epa1--;
            if (servo2epa1 < 1)
            {
              servo2epa1 = 1;
            }
          }
          if (islevsira == 2)
          {
            servo2epa2--;
            if (servo2epa2 < 1)
            {
              servo2epa2 = 1;
            }
          }
        }
        if (servosira == 3)
        {
          if (islevsira == 1)
          {
            servo3cnt--;
            if (servo3cnt < (-700))
            {
              servo3cnt = -700;
            }
          }
          if (islevsira == 2)
          {
            servo3epa1--;
            if (servo3epa1 < 1)
            {
              servo3epa1 = 1;
            }
          }
          if (islevsira == 2)
          {
            servo3epa2--;
            if (servo3epa2 < 1)
            {
              servo3epa2 = 1;
            }
          }
        }
        break;
      case 4: // Burada o an seçili olan parametreyi bir artıracağız. Range check yapıp düzelteceğiz.
        if (servosira == 1)
        {
          if (islevsira == 1)
          {
            servo1cnt++;
            if (servo1cnt > 700)
            {
              servo1cnt = 700;
            }
          }
          if (islevsira == 2)
          {
            servo1epa1++;
            if (servo1epa1 > 700)
            {
              servo1epa1 = 700;
            }
          }
          if (islevsira == 2)
          {
            servo1epa2++;
            if (servo1epa2 > 700)
            {
              servo1epa2 = 700;
            }
          }
        }
        if (servosira == 2)
        {
          if (islevsira == 1)
          {
            servo1cnt++;
            if (servo2cnt > 700)
            {
              servo2cnt = 700;
            }
          }
          if (islevsira == 2)
          {
            servo2epa1++;
            if (servo2epa1 > 700)
            {
              servo2epa1 = 700;
            }
          }
          if (islevsira == 2)
          {
            servo2epa2++;
            if (servo2epa2 > 700)
            {
              servo2epa2 = 700;
            }
          }
        }
        if (servosira == 3)
        {
          if (islevsira == 1)
          {
            servo3cnt++;
            if (servo3cnt > 700)
            {
              servo3cnt = 700;
            }
          }
          if (islevsira == 2)
          {
            servo3epa1++;
            if (servo3epa1 > 700)
            {
              servo3epa1 = 700;
            }
          }
          if (islevsira == 2)
          {
            servo3epa2++;
            if (servo3epa2 > 700)
            {
              servo3epa2 = 700;
            }
          }
        }
        break;
    }


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

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

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


  }
  EEPROMyaz();
  while (1 == 1) // Burada artık programı kilitliyoruz. Servo LED'leri hızlı yanıp sönüyorlar. Artık programlama bitti. Sistemin resetlenmesi gerekiyor.
  {
    digitalWrite(servo1, HIGH);
    digitalWrite(servo2, HIGH);
    digitalWrite(servo3, HIGH);
    delay(100);
    digitalWrite(servo1, LOW);
    digitalWrite(servo2, LOW);
    digitalWrite(servo3, LOW);
    delay(100);
  }
}


int keypress() // 0: Geçerli tuş yok. 1: Mode1. 2: Mode2. 3: Decrease. 4: Increase. 5: Done.
{


}

void EEPROMoku()
{
  servo1cnt = EEPROM.read(1) + 256 * EEPROM.read(0);
  servo1epa1 = EEPROM.read(3) + 256 * EEPROM.read(2);
  servo1epa2 = EEPROM.read(5) + 256 * EEPROM.read(4);
  servo2cnt = EEPROM.read(7) + 256 * EEPROM.read(6);
  servo2epa1 = EEPROM.read(9) + 256 * EEPROM.read(:coolxf:;
  servo2epa2 = EEPROM.read(11) + 256 * EEPROM.read(10);
  servo3cnt = EEPROM.read(13) + 256 * EEPROM.read(12);
  servo3epa1 = EEPROM.read(15) + 256 * EEPROM.read(14);
  servo3epa2 = EEPROM.read(17) + 256 * EEPROM.read(16);
}


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

  hibyte = servo1epa1 / 256;
  lobyte = servo1epa1 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo1epa2 / 256;
  lobyte = servo1epa2 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo2cnt / 256;
  lobyte = servo2cnt - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo2epa1 / 256;
  lobyte = servo2epa1 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo2epa2 / 256;
  lobyte = servo2epa2 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo3cnt / 256;
  lobyte = servo3cnt - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo3epa1 / 256;
  lobyte = servo3epa1 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo3epa2 / 256;
  lobyte = servo3epa2 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

}


void EEPROMtest() // EEPROM testi yapılıp flag ile sonuç bildiriliyor
{
  eepromerror = 0;
  unsigned int a[18];
  unsigned long b = 0;
  unsigned int temp;
  for (int i = 0; i < 18; i++)
  {
    a[i] = EEPROM.read(i);
    b = b + a[i];
  }
  if (b == 4590)
  {
    temp = EEPROM.read(0);
    EEPROM.write(0, 0);
    if (EEPROM.read(0) != 0)
    {
      eepromerror = 1;
    }
    EEPROM.write(0, temp);
  }
}


void servoout() // MsTimer2 üzerinden interruptlarla her 20 mS'de bir çağrılıyor ve yaklaşık 3 - 6 mS sürüyor
{
  timer = micros();
  digitalWrite(servo1, HIGH);
  while ((micros() - timer) < servo1PWM)
  {
  }
  digitalWrite(servo1, LOW);

  timer = micros();
  digitalWrite(servo2, HIGH);
  while ((micros() - timer) < servo2PWM)
  {
  }
  digitalWrite(servo2, LOW);

  timer = micros();
  digitalWrite(servo3, HIGH);
  while ((micros() - timer) < servo3PWM)
  {
  }
  digitalWrite(servo3, LOW);
}

void servo1out()
{
  timer = micros();
  digitalWrite(servo1, HIGH);
  while ((micros() - timer) < servo1PWM)
  {
  }
  digitalWrite(servo1, LOW);
  while ((micros() - timer) < 20000)
  {
  }
}

void servo2out()
{
  timer = micros();
  digitalWrite(servo2, HIGH);
  while ((micros() - timer) < servo2PWM)
  {
  }
  digitalWrite(servo2, LOW);
  while ((micros() - timer) < 20000)
  {
  }
}

void servo3out()
{
  timer = micros();
  digitalWrite(servo3, HIGH);
  while ((micros() - timer) < servo3PWM)
  {
  }
  digitalWrite(servo3, LOW);
  while ((micros() - timer) < 20000)
  {
  }
}

 

[Sumer Yamaner]

Servo senkronizasyon modülü

Butonların okunması da halledildi...

Önce dört buton girişi de okunuyor. Butonlar basılı ise "0", basılı değil ise "1" değeri veriyorlar.
Önce programlamanın tamamlandığını gösteren kombinasyon araştırılıyor. Yani her iki MODE butonuna basılı tutup iki saniye beklenmesi lazım.
Yani bir ve iki no'lu tuşlar "0", diğer iki tuş "1" olmalı. Eğer böyle ise bu tuşları iki saniye boyunca okuyoruz. Okurken herhangi bir anda tuşlardan birinin bırakılması halinde herhangi bir tuşa basılmadı kodu yani "0" döndürüyoruz.
İki saniye boyunca tuşlar bırakılmadı ise Save & Exit komutu olan "5" döndürüyoruz.
Bu aşamadan sonra bir ve iki no'lu tuşları karşılaştırıp eğer eşit değil ise (yani birinden birine basıldıysa) flag1'i set ediyoruz.
Aynısını üç ve dört no'lu tuşlar için yapıp flag2'yi set ediyoruz. Eğer flag1 ve flag2'nin ikisi de set edilmiş ise birden fazla tuşa basılmış demektir. Ya da ikisi de "0" ise herhangi bir tuşa basılmamış demektir. Her iki durumda da "herhangi bir tuşa basılmadı" kodu yani "0" döndürüyoruz.
Bu aşamayı da geçtiysek demektir ki sadece bir tuşa basılmış. Bu durumda tuşları kaydettiğimiz değişkenleri tek tek kontrol edip hangisi "0" ise o değeri (1 ... 4 arası) döndürüyoruz.

  int flag1 = 0;
  int flag2 = 0;
  int result = 0;

  int pressed1 = 1;
  int pressed2 = 1;
  int pressed3 = 1;
  int pressed4 = 1;


  pressed1 = digitalRead(mode1);
  pressed2 = digitalRead(mode2);
  pressed3 = digitalRead(decrease);
  pressed4 = digitalRead(increase);

  delay(20); // Debounce için
  
  pressed1 = pressed1 + digitalRead(mode1);
  pressed2 = pressed2 + digitalRead(mode2);
  pressed3 = pressed3 + digitalRead(decrease);
  pressed4 = pressed4 + digitalRead(increase);
  
  if(pressed1 > 1) pressed1 = 1;
  if(pressed2 > 1) pressed2 = 1;
  if(pressed3 > 1) pressed3 = 1;
  if(pressed4 > 1) pressed4 = 1;  


  if ((pressed1 == 0) && (pressed2 == 0) && (pressed3 == 1) && (pressed4 == 1)) // Save & Exit tuşu
  {
    for (int i = 0; i < 40; i = i + 2)
    {
      if (digitalRead(mode1) == 1) return (0);
      if (digitalRead(mode2) == 1) return (0);
      delay(50);
    }
    return (5);
  }

  if (pressed1 != pressed2) flag1 = 1;
  if (pressed3 != pressed4) flag2 = 1;

  if (flag1 == flag2) return (0);

  if (pressed1 == 0) return (1);
  if (pressed2 == 0) return (2);
  if (pressed3 == 0) return (3);
  if (pressed4 == 0) return (4);

 

[Sumer Yamaner]

Servo senkronizasyon modülü

Sonunda test için hazır hale gelen kod:

#include <MsTimer2.h>
#include <EEPROM.h>

const byte servoin = 3;
const byte servo1 = 6;
const byte servo2 = 5;
const byte servo3 = 4;
const byte mode1 = 14;
const byte mode2 = 15;
const byte decrease = 16;
const byte increase = 17;
const byte centerLED = 12;
const byte epa1LED = 11;
const byte epa2LED = 10;
const byte servo1LED = 9;
const byte servo2LED = 8;
const byte servo3LED = 7;

volatile unsigned int servoinPWM = 1500;
volatile unsigned int servo1PWM = 1500;
volatile unsigned int servo2PWM = 1500;
volatile unsigned int servo3PWM = 1500;

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;

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

  if (digitalRead(mode1) != digitalRead(mode2))
  {
    keyflag = 1;
  }
  delay(100);
  if (digitalRead(mode1) != digitalRead(mode2))
  {
    progflag = 1;
    keyflag = 0;
  }

  EEPROMtest();

  if (eepromerror > 0) // EEPROM hatasında servo LED'lerini yakıp söndürerek beklemede kalıyoruz. Programa girmiyoruz. Güç kesilene kadar böyle devam.
  {
    while (eepromerror > 0)
    {
      digitalWrite(servo1, HIGH);
      digitalWrite(servo2, HIGH);
      digitalWrite(servo3, HIGH);
      delay(300);
      digitalWrite(servo1, LOW);
      digitalWrite(servo2, LOW);
      digitalWrite(servo3, LOW);
      delay(300);
    }
  }

  EEPROMoku();
  if (progflag == 0)
  {
    MsTimer2::set(20, servoout);
    MsTimer2::start();
  }
}

void loop()
{
  if (progflag == 0)
  {
    normal();
  }
  else
  {
    progmode();
  }
}

void normal() // Programlama modunda değilsek loop()'tan sürekli bu işlev çağrılıyor
{
  servoinPWM = pulseIn(servoin, HIGH, 21000); //Alıcıdan sinyali mikrosaniye olarak okuyoruz
  x = servoinPWM - 1500; // x -700 ile + 700 arasında bir değer alıyor
  if (x < 0)
  {
    servo1PWM = 1500 - ((x * servo1epa1) / 700) + servo1cnt; //Servo1 için çıkış değeri oluşturuluyor
    servo2PWM = 1500 - ((x * servo2epa1) / 700) + servo2cnt; //Servo2 için çıkış değeri oluşturuluyor
    servo3PWM = 1500 - ((x * servo3epa1) / 700) + servo3cnt; //Servo3 için çıkış değeri oluşturuluyor
  }
  else
  {
    servo1PWM = ((x * servo1epa2) / 700) + 1500 + servo1cnt; //Servo1 için çıkış değeri oluşturuluyor
    servo2PWM = ((x * servo2epa2) / 700) + 1500 + servo2cnt; //Servo2 için çıkış değeri oluşturuluyor
    servo3PWM = ((x * servo3epa2) / 700) + 1500 + servo3cnt; //Servo3 için çıkış değeri oluşturuluyor
  }
}

void progmode() // Programlama modunda isek loop()'tan sürekli bu çağrılıyor
{
  int servosira = 1; // 1 No'lu servo ile başlıyoruz
  int islevsira = 1; // Center modu ile başlıyoruz. 1: Center, 2: Alt EPA, 3: Üst EPA
  int pressedkey = 0; // 0: Key yok, 1: Mode1(servo), 2: Mode2(işlev), 3: Decrease, 4: Increase, 5: Exit

  while (pressedkey < 5)
  {
    switch (islevsira)
    {
      case 1:
        servo1PWM = 1500 + servo1cnt;
        servo2PWM = 1500 + servo2cnt;
        servo3PWM = 1500 + servo3cnt;
        break;
      case 2:
        servo1PWM = 1500 + servo1cnt - servo1epa1;
        servo2PWM = 1500 + servo2cnt - servo2epa1;
        servo3PWM = 1500 + servo3cnt - servo3epa1;
        break;
      case 3:
        servo1PWM = 1500 + servo1cnt - servo1epa2;
        servo2PWM = 1500 + servo2cnt - servo2epa2;
        servo3PWM = 1500 + servo3cnt - servo3epa2;
        break;
    }

    switch (servosira)
    {
      case 1:
        servo1out();
        break;
      case 2:
        servo2out();
        break;
      case 3:
        servo3out();
        break;
    }
    pressedkey = keypress();
    switch (pressedkey)
    {
      case 1:
        servosira++;
        if (servosira > 3)
        {
          servosira = 1;
        }
        break;
      case 2:
        islevsira++;
        if (islevsira > 3)
        {
          islevsira = 1;
        }
        break;
      case 3: // Burada o an seçili olan parametreyi bir azaltacağız. Range check yapıp düzelteceğiz.
        if (servosira == 1)
        {
          if (islevsira == 1)
          {
            servo1cnt--;
            if (servo1cnt < (-700))
            {
              servo1cnt = -700;
            }
          }
          if (islevsira == 2)
          {
            servo1epa1--;
            if (servo1epa1 < 1)
            {
              servo1epa1 = 1;
            }
          }
          if (islevsira == 2)
          {
            servo1epa2--;
            if (servo1epa2 < 1)
            {
              servo1epa2 = 1;
            }
          }
        }
        if (servosira == 2)
        {
          if (islevsira == 1)
          {
            servo1cnt--;
            if (servo2cnt < (-700))
            {
              servo2cnt = -700;
            }
          }
          if (islevsira == 2)
          {
            servo2epa1--;
            if (servo2epa1 < 1)
            {
              servo2epa1 = 1;
            }
          }
          if (islevsira == 2)
          {
            servo2epa2--;
            if (servo2epa2 < 1)
            {
              servo2epa2 = 1;
            }
          }
        }
        if (servosira == 3)
        {
          if (islevsira == 1)
          {
            servo3cnt--;
            if (servo3cnt < (-700))
            {
              servo3cnt = -700;
            }
          }
          if (islevsira == 2)
          {
            servo3epa1--;
            if (servo3epa1 < 1)
            {
              servo3epa1 = 1;
            }
          }
          if (islevsira == 2)
          {
            servo3epa2--;
            if (servo3epa2 < 1)
            {
              servo3epa2 = 1;
            }
          }
        }
        break;
      case 4: // Burada o an seçili olan parametreyi bir artıracağız. Range check yapıp düzelteceğiz.
        if (servosira == 1)
        {
          if (islevsira == 1)
          {
            servo1cnt++;
            if (servo1cnt > 700)
            {
              servo1cnt = 700;
            }
          }
          if (islevsira == 2)
          {
            servo1epa1++;
            if (servo1epa1 > 700)
            {
              servo1epa1 = 700;
            }
          }
          if (islevsira == 2)
          {
            servo1epa2++;
            if (servo1epa2 > 700)
            {
              servo1epa2 = 700;
            }
          }
        }
        if (servosira == 2)
        {
          if (islevsira == 1)
          {
            servo1cnt++;
            if (servo2cnt > 700)
            {
              servo2cnt = 700;
            }
          }
          if (islevsira == 2)
          {
            servo2epa1++;
            if (servo2epa1 > 700)
            {
              servo2epa1 = 700;
            }
          }
          if (islevsira == 2)
          {
            servo2epa2++;
            if (servo2epa2 > 700)
            {
              servo2epa2 = 700;
            }
          }
        }
        if (servosira == 3)
        {
          if (islevsira == 1)
          {
            servo3cnt++;
            if (servo3cnt > 700)
            {
              servo3cnt = 700;
            }
          }
          if (islevsira == 2)
          {
            servo3epa1++;
            if (servo3epa1 > 700)
            {
              servo3epa1 = 700;
            }
          }
          if (islevsira == 2)
          {
            servo3epa2++;
            if (servo3epa2 > 700)
            {
              servo3epa2 = 700;
            }
          }
        }
        break;
    }


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

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

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


  }
  EEPROMyaz();
  while (1 == 1) // Burada artık programı kilitliyoruz. Servo LED'leri hızlı yanıp sönüyorlar. Artık programlama bitti. Sistemin resetlenmesi gerekiyor.
  {
    digitalWrite(servo1LED, HIGH);
    digitalWrite(servoLED2, HIGH);
    digitalWrite(servoLED3, HIGH);
    delay(100);
    digitalWrite(servoLED1, LOW);
    digitalWrite(servoLED2, LOW);
    digitalWrite(servoLED3, LOW);
    delay(100);
  }
}


int keypress() // 0: Geçerli tuş yok. 1: Mode1. 2: Mode2. 3: Decrease. 4: Increase. 5: Done.
{
  int flag1 = 0;
  int flag2 = 0;
  int result = 0;

  int pressed1 = 1;
  int pressed2 = 1;
  int pressed3 = 1;
  int pressed4 = 1;
  


  pressed1 = digitalRead(mode1);
  pressed2 = digitalRead(mode2);
  pressed3 = digitalRead(decrease);
  pressed4 = digitalRead(increase);
  
  delay(20); // Debounce için
  
  pressed1 = pressed1 + digitalRead(mode1);
  pressed2 = pressed2 + digitalRead(mode2);
  pressed3 = pressed3 + digitalRead(decrease);
  pressed4 = pressed4 + digitalRead(increase);
  
  if(pressed1 > 1) pressed1 = 1;
  if(pressed2 > 1) pressed2 = 1;
  if(pressed3 > 1) pressed3 = 1;
  if(pressed4 > 1) pressed4 = 1;  


  if ((pressed1 == 0) && (pressed2 == 0) && (pressed3 == 1) && (pressed4 == 1)) // Save & Exit tuşu
  {
    for (int i = 0; i < 40; i = i + 2)
    {
      if (digitalRead(mode1) == 1) return (0);
      if (digitalRead(mode2) == 1) return (0);
      delay(50);
    }
    return (5);
  }

  if (pressed1 != pressed2) flag1 = 1;
  if (pressed3 != pressed4) flag2 = 1;

  if (flag1 == flag2) return (0);

  if (pressed1 == 0) return (1);
  if (pressed2 == 0) return (2);
  if (pressed3 == 0) return (3);
  if (pressed4 == 0) return (4);
}

void EEPROMoku()
{
  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);
}


void EEPROMyaz()
{
  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(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo1epa2 / 256;
  lobyte = servo1epa2 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

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

  hibyte = servo2epa1 / 256;
  lobyte = servo2epa1 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo2epa2 / 256;
  lobyte = servo2epa2 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

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

  hibyte = servo3epa1 / 256;
  lobyte = servo3epa1 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

  hibyte = servo3epa2 / 256;
  lobyte = servo3epa2 - 256 * hibyte;
  EEPROM.write(0, hibyte);
  EEPROM.write(1, lobyte);

}


void EEPROMtest() // EEPROM testi yapılıp flag ile sonuç bildiriliyor
{
  eepromerror = 0;
  unsigned int a[18];
  unsigned long b = 0;
  unsigned int temp;
  for (int i = 0; i < 18; i++)
  {
    a[i] = EEPROM.read(i);
    b = b + a[i];
  }
  if (b == 4590)
  {
    temp = EEPROM.read(0);
    EEPROM.write(0, 0);
    if (EEPROM.read(0) != 0)
    {
      eepromerror = 1;
    }
    EEPROM.write(0, temp);
  }
}


void servoout() // MsTimer2 üzerinden interruptlarla her 20 mS'de bir çağrılıyor ve yaklaşık 3 - 6 mS sürüyor
{
  timer = micros();
  digitalWrite(servo1, HIGH);
  while ((micros() - timer) < servo1PWM)
  {
  }
  digitalWrite(servo1, LOW);

  timer = micros();
  digitalWrite(servo2, HIGH);
  while ((micros() - timer) < servo2PWM)
  {
  }
  digitalWrite(servo2, LOW);

  timer = micros();
  digitalWrite(servo3, HIGH);
  while ((micros() - timer) < servo3PWM)
  {
  }
  digitalWrite(servo3, LOW);
}

void servo1out()
{
  timer = micros();
  digitalWrite(servo1, HIGH);
  while ((micros() - timer) < servo1PWM)
  {
  }
  digitalWrite(servo1, LOW);
  while ((micros() - timer) < 20000)
  {
  }
}

void servo2out()
{
  timer = micros();
  digitalWrite(servo2, HIGH);
  while ((micros() - timer) < servo2PWM)
  {
  }
  digitalWrite(servo2, LOW);
  while ((micros() - timer) < 20000)
  {
  }
}

void servo3out()
{
  timer = micros();
  digitalWrite(servo3, HIGH);
  while ((micros() - timer) < servo3PWM)
  {
  }
  digitalWrite(servo3, LOW);
  while ((micros() - timer) < 20000)
  {
  }
}

 

[Mehmet Kucuksari]

Servo senkronizasyon modülü

Sonunda test için hazır hale gelen kod:

Ve test sonucu ??

 

[Sumer Yamaner]

Servo senkronizasyon modülü

Ne yazık ki el süremedim henüz. Hafta sonu hanıma teslim olduk!

 

[Zafer ŞAHİN]

Servo senkronizasyon modülü

Sümer abi, array ile kod sanki biraz daha kısalır gibi geldi ...

#include <MsTimer2.h>
#include <EEPROM.h>

const byte servoin = 3;
const byte servo[3] = {6,5,4};
const byte mode[2] = {14,15};
const byte decrease = 16;
const byte increase = 17;
const byte centerLED = 12;
const byte epaLED[2] = {11,10};
const byte servoLED[3] = {9,8,7};

volatile unsigned int servoinPWM = 1500;
volatile unsigned int servoPWM[3] = {1500,1500,1500};

long x;
volatile byte progflag = 0;
volatile byte keyflag = 0;
byte eepromerror = 0;

byte hibyte;
byte lobyte;
unsigned long timer;

int servocnt[3];
unsigned int servoepa[3][2] = {
    {1,1},
    {1,1},
    {1,1}
};

void setup(){
    pinMode(mode[0], INPUT_PULLUP);
    pinMode(mode[1], INPUT_PULLUP);
    pinMode(increase, INPUT_PULLUP);
    pinMode(decrease, INPUT_PULLUP);
    pinMode(centerLED, OUTPUT);
    pinMode(epaLED[0], OUTPUT);
    pinMode(epaLED[1], OUTPUT);
    for(int i=0;i<3;i++){
        pinMode(servoLED[i], OUTPUT);
        pinMode(servo[i], OUTPUT);
    }

    if (digitalRead(mode[0]) != digitalRead(mode[1])){
        keyflag = 1;
    }
    delay(100);
    if (digitalRead(mode[0]) != digitalRead(mode[1])){
        progflag = 1;
        keyflag = 0;
    }

    eepromerror = EEPROMtest();

    if (eepromerror > 0){ // EEPROM hatasında servo LED'lerini yakıp söndürerek beklemede kalıyoruz. Programa girmiyoruz. Güç kesilene kadar böyle devam.
        while (true){
            for(int i=0;i<3;i++){
                digitalWrite(servo[i], HIGH);
                delay(300);
                digitalWrite(servo[i], LOW);
            }
        }
    }

    EEPROMoku();
    if (progflag == 0){
        MsTimer2::set(20, servoout);
        MsTimer2::start();
    }
}

void loop(){
    if (progflag == 0){
        normal();
    } else {
        progmode();
    }
}

void normal(){ // Programlama modunda değilsek loop()'tan sürekli bu işlev çağrılıyor
    servoinPWM = pulseIn(servoin, HIGH, 21000); //Alıcıdan sinyali mikrosaniye olarak okuyoruz
    x = servoinPWM - 1500; // x -700 ile + 700 arasında bir değer alıyor
    if (x < 0) {
        for(int i=0;i<3;i++){
            servoPWM[i] = 1500 - ((x * servoepa[i][0]) / 700) + servocnt[i]; //Servo i için çıkış değeri oluşturuluyor
        }
    } else {
        for(int i=0;i<3;i++){
            servoPWM[i] = 1500 + ((x * servoepa[i][1]) / 700) + servocnt[i]; //Servo i için çıkış değeri oluşturuluyor
        }
    }
}

void progmode(){ // Programlama modunda isek loop()'tan sürekli bu çağrılıyor
    int servosira = 1; // 1 No'lu servo ile başlıyoruz
    int islevsira = 1; // Center modu ile başlıyoruz. 1: Center, 2: Alt EPA, 3: Üst EPA
    int pressedkey = 0; // 0: Key yok, 1: Mode1(servo), 2: Mode2(işlev), 3: Decrease, 4: Increase, 5: Exit
    int ss = servosira - 1;
    int is = islevsira - 1;
    while (pressedkey < 5){
        switch (islevsira){
            case 1:
                for(int i=0;i<3;i++){
                    servoPWM[i] = 1500 + servocnt[i];
                }
            break;
            case 2:
                for(int i=0;i<3;i++){
                    servoPWM[i] = 1500 + servocnt[i] - servoepa[i][0];
                }
            break;
            case 3:
                for(int i=0;i<3;i++){
                    servoPWM[i] = 1500 + servocnt[i] - servoepa[i][1];
                }
            break;
        }
        ss = servosira - 1;
        servoNout(ss);
        
        pressedkey = keypress();
        switch (pressedkey){
            case 1:
                servosira++;
                if (servosira > 3){
                    servosira = 1;
                }
            break;
            case 2:
                islevsira++;
                if (islevsira > 3){
                    islevsira = 1;
                }
            break;
            case 3: // Burada o an seçili olan parametreyi bir azaltacağız. Range check yapıp düzelteceğiz.
                if (islevsira == 1){
                    servocnt[ss]--;
                    if (servocnt[ss] < (-700)){
                        servocnt[ss] = -700;
                    }
                }
                if (islevsira == 2){
                    servoepa[ss][0]--;
                    if (servoepa[ss][0] < 1){
                        servoepa[ss][0] = 1;
                    }
                }
                if (islevsira == 3){
                    servoepa[ss][1]--;
                    if (servoepa[ss][1] < 1){
                        servoepa[ss][1] = 1;
                    }
                }
            break;
            case 4: // Burada o an seçili olan parametreyi bir artıracağız. Range check yapıp düzelteceğiz.
                if (islevsira == 1){
                    servocnt[ss]++;
                    if (servocnt[ss] > 700){
                        servocnt[ss] = 700;
                    }
                }
                if (islevsira == 2){
                    servoepa[ss][0]++;
                    if (servoepa[ss][0] > 700){
                        servoepa[ss][0] = 700;
                    }
                }
                if (islevsira == 3){
                    servoepa[ss][1]++;
                    if (servoepa[ss][1] > 700){
                        servoepa[ss][1] = 700;
                    }
                }
            break;
        }
        
        if (pressedkey != 0){
            digitalWrite(centerLED, LOW);
            digitalWrite(epaLED[0], LOW);
            digitalWrite(epaLED[1], LOW);
            digitalWrite(servoLED[0], LOW);
            digitalWrite(servoLED[1], LOW);
            digitalWrite(servoLED[2], LOW);
            ss = servosira - 1;
            digitalWrite(servoLED[ss], HIGH);
            switch (islevsira){
                case 1:
                    digitalWrite(centerLED, HIGH);
                break;
                case 2:
                    digitalWrite(epaLED[0], HIGH);
                break;
                case 3:
                    digitalWrite(epaLED[1], HIGH);
                break;
            }
        }
    }
    EEPROMyaz();
    while (true){ // Burada artık programı kilitliyoruz. Servo LED'leri hızlı yanıp sönüyorlar. Artık programlama bitti. Sistemin resetlenmesi gerekiyor.
        for(int i=0;i<3;i++){
            digitalWrite(servo[i], HIGH);
            delay(100);
            digitalWrite(servo[i], LOW);
        }
    }
}

int keypress(){ // 0: Geçerli tuş yok. 1: Mode 1. 2: Mode2. 3: Decrease. 4: Increase. 5: Done.
    int flag[2] = {0,0};
    int result = 0;

    int pressed[4] = {1,1,1,1};

    pressed[0] = digitalRead(mode[0]);
    pressed[1] = digitalRead(mode[1]);
    pressed[2] = digitalRead(decrease);
    pressed[3] = digitalRead(increase);

    delay(20); // Debounce için

    pressed[0] = pressed[0] + digitalRead(mode[0]);
    pressed[1] = pressed[1] + digitalRead(mode[1]);
    pressed[2] = pressed[2] + digitalRead(decrease);
    pressed[3] = pressed[3] + digitalRead(increase);

    for(int i=0;i<4;i++){
        if(pressed[i] > 1) pressed[i] = 1;
    }

    if ((pressed[0] == 0)&&(pressed[1] == 0)&&(pressed[2] == 1)&&(pressed[3] == 1)){ // Save & Exit tuşu
        for (int i = 0; i < 40; i = i + 2){
            if (digitalRead(mode[0]) == 1) return (0);
            if (digitalRead(mode[1]) == 1) return (0);
            delay(50);
        }
        return (5);
    }

    if (pressed[0] != pressed[1]) flag[0] = 1;
    if (pressed[2] != pressed[3]) flag[1] = 1;

    if (flag[0] == flag[1]) return (0);

    for(int i=0;i<4;i++){
        if (pressed[i] == 0) return (i+1);
    }
}

void EEPROMoku(){
    for(int i=0;i<3;i++){
        servocnt[i] = EEPROM.read(6*i+1) + 256 * EEPROM.read(6*i+0);
        servoepa[i][0] = EEPROM.read(6*i+3) + 256 * EEPROM.read(6*i+2);
        servoepa[i][1] = EEPROM.read(6*i+5) + 256 * EEPROM.read(6*i+4);
    }
}

void EEPROMyaz(){
    for(int i=0;i<3;i++){
        hibyte = servocnt[i] / 256;
        lobyte = servocnt[i] - 256 * hibyte;
        EEPROM.write(0, hibyte);
        EEPROM.write(1, lobyte);

        hibyte = servoepa[i][0] / 256;
        lobyte = servoepa[i][0] - 256 * hibyte;
        EEPROM.write(0, hibyte);
        EEPROM.write(1, lobyte);

        hibyte = servoepa[i][1] / 256;
        lobyte = servoepa[i][1] - 256 * hibyte;
        EEPROM.write(0, hibyte);
        EEPROM.write(1, lobyte);
    }
}

byte EEPROMtest(){ // EEPROM testi yapılıp flag ile sonuç bildiriliyor
    byte eepromerror = 0;
    unsigned int a[18];
    unsigned long b = 0;
    unsigned int temp;
    for (int i = 0; i < 18; i++){
        a[i] = EEPROM.read(i);
        b = b + a[i];
    }
    if (b == 4590){
        temp = EEPROM.read(0);
        EEPROM.write(0, 0);
        if (EEPROM.read(0) != 0){
            eepromerror = 1;
        }
        EEPROM.write(0, temp);
    }
    return eepromerror;
}

void servoout(){ // MsTimer2 üzerinden interruptlarla her 20 mS'de bir çağrılıyor ve yaklaşık 3 - 6 mS sürüyor
    for(int i=0;i<3;i++){
        timer = micros();
        digitalWrite(servo[i], HIGH);
        while ((micros() - timer) < servoPWM[i]){
        }
        digitalWrite(servo[0], LOW);
    }
}

void servoNout(int servoN){
    timer = micros();
    digitalWrite(servo[servoN], HIGH);
    while ((micros() - timer) < servoPWM[servoN]){
    }
    digitalWrite(servo[servoN], LOW);
    while ((micros() - timer) < 20000){
    }
}

 

[Sumer Yamaner]

Servo senkronizasyon modülü

Özel mesaj attım. Şu an telefondan giriyorum. Bilgisayarıma ulaşınca ayrıntılı bakacağım. Array bence de hoş olur.

 

[Sumer Yamaner]

Servo senkronizasyon modülü

Hafta sonu evde olmayınca tüm çalışmalar aksadı. Ancak giderken beynimi yanıma almış olmam iyi oldu. Arada Zafer kardeşim ile de epey bir mesajlaştık. Sağolsun her yanıtıyla ufkumu açıyor.
İki önemli sorunu çözdüğümü düşünüyorum. Bunlardan birisini tesadüfen farkettim. Bir "if" terimi içinde birden fazla koşulun gerçekleşmesini istediğimizde "AND" işlemini kullanıyoruz. Ancak tek "&" sembolü "bitwise AND" yapıyor. Halbuki benim amaçladığım "logical AND" yapılması. Onun doğru kodu ise "&&". Bunu farkedip düzelttim.
Diğer konu ise değerlerin EEPROM'a yazılıp oradan okunması konusu idi. Benim yöntemimde unsigned int olan EPA değişkenlerinde sorun yoktu ama eğer negatif değer de alabilen CNT değişkenlerini bu şekilde yazıp okursam negatif sayılarda hata oluşacaktı. Bununla ilgili birçok çözüm seçeneği var ama az önce aklıma çok basit bir çözüm geldi. CNT değeri - 700 ile + 700 arası değişebiliyor. Dolayısıyla eğer ben EEPROM'a yazarken buna 2000 eklersem (1000 de olabilirdi) değer her durumda pozitif olacak ama +32767'lik tavan değeri de hiçbir şekilde aşmayacak. Okurken de hibyte ve lobyte üzerinden değişkeni rekonstrükte edip 2000 çıkarırsam orijinal değere ulaşabileceğim (sanıyorum). (Temel ilke ve öneri Zafer Şahin'e aittir! )
Kodda compiler hatası yok. Mutlaka bir sürü mantık hatası gizlidir bir yerlerde. Onu da inşallah bu akşam göreceğiz.

 

[Mehmet Kucuksari]

Servo senkronizasyon modülü

Hafta sonu evde olmayınca tüm çalışmalar aksadı. Ancak giderken beynimi yanıma almış olmam iyi oldu. Arada Zafer kardeşim ile de epey bir mesajlaştık. Sağolsun her yanıtıyla ufkumu açıyor.

Valla abi sen ve zafer hocam süper bir ikili oldunuz. Ailecek severek izliyoruz sizleri

 

[Sumer Yamaner]

Servo senkronizasyon modülü

Valla abi sen ve zafer hocam süper bir ikili oldunuz. Ailecek severek izliyoruz sizleri

İkili mi olduk ne olduk bilemem ama adam yaptığı büyük hatanın ceremesini çekiyor, onu biliyorum!

 

[Sumer Yamaner]

EEPROM okuma, EEPROM test, test sonucu hata verirse LED'lerin yakılıp söndürülerek programın kilitlenmesi, çalışma anında MODE1 butonu basılı tutularak programlama moduna girilmesi, butonlarla seçenekler arasında gezinme test edildi bu akşam. Butonlar ara ara çift atlıyor ara ara da takılıyor ama düzeltilir. Daha geç vakit programlama modunda veri değişimlerini inceleyeceğim. Bakalım oluyor mu. Sonra da EEPROM yazmayı test edeceğim.
MsTimer2 aktive edilince program kilitleniyor. Bu durumda interrupt ve timer konusuna doğrudan müdahale ederek sorunu çözeceğim demektir. Şimdilik bu kadar.