[DIY]: Arduino ile Rectract - Iniş Takımı Uygulaması

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Retractlarımız çok boşlandı...

Bu akşam epey uğraştım. Tek bir elektrik motoru, L293 sürücü, akım sensörü vs ile bir prototip oluşturdum. Tek retractı kontrol edecek basitleştirilmiş de bir kod yazdım. Ne yazık ki aptalca bir şey yapmışım. L293'ün 8 No'lu bacağını yanlış anlayıp 0 V'a bağlamışım. Tabii ne yaptıysam motoru çalıştıramadım. Sonra antiparalel bağlı LED'ler kullandım, programa debug amaçlı Serial.print komutları ekledim. Akım sensörünü devre dışı bırakıp stop butonu ekledim. Sonunda aşağıdaki kod çalıştı.
Daha sonra L293 testlerinde hatamı bulup çalışır hale getirdim ama bu saatten sonra akım sensörlü sistemle uğraşmak istemedim.
Halihazır durumda retract komutu ile anlık pozisyon karşılaştırılıyor. Farklı ise açma ya da kapama alt programları çağrılıyor. Bu alt programlar da motoru çalıştırıp butona basılmasını bekliyorlar. Daha sonra buton işlevi akım sensörü ile değiştirilecek ama bu bence kolay bir eklenti olacak. İnşallah yarına...

int rxPin = 12; //Alıcı sinyali 12 nolu pinde
int motor_l1 = 3; // Sol retract motoru 3 ve 4 nolu pinlerde
int motor_l2 = 4;
//int sensor_l = 1; // Sol akım sensörü 1 nolu analog girişte
//int cur_l = 0; // Sol akım
int ret_com = 1; // Retract komutu Açık = 1 Kapalı = 0
int ret_pos = 1; // Aktüel retract pozisyonu Açık = 1, Kapalı = 0
int rxPWM = 0; //Alıcı sinyalini depolayan değişken
//int x = 0; //Motor akım kontrolünde kullanılacak değişiken
//int maxcur = 550; // Azami pozitif akım. Akım sensörüne ve motora göre bu değer değiştirilecek
//int mincur = 470; // Azami negatif akım. Akım sensörüne ve motora göre bu değer değiştirilecek
//int normcur1 = 530; // Beklenen normal pozitif akım. Akım sensörüne ve motora göre bu değer değiştirilecek
//int normcur2 = 490; // Beklenen normal negatif akım. Akım sensörüne ve motora göre bu değer değiştirilecek
int senspin = 10; // Buton 10 numaralı digital girişe bağlı
int sense = 1; // Butona basıldığında LOW olan değişken


void setup()
{
  pinMode(motor_l1, OUTPUT);
  pinMode(motor_l2, OUTPUT);
  digitalWrite(motor_l1, LOW);
  digitalWrite(motor_l2, LOW);
  pinMode(senspin, INPUT);
  rxPWM = pulseIn(rxPin, HIGH, 25000);
  while(rxPWM < 800 || rxPWM > 2200) // Burada valid bir alıcı sinyali bekliyoruz
  {
    rxPWM = pulseIn(rxPin, HIGH, 25000);
  }
  if(rxPWM < 1500)
  {
    ret_com = 0; // PWM 1.5 ms altında retract kapalı komutu
  }
  else
  {
    ret_com = 1; // PWM 1.5 ms üstünde retract açık komutu
  }

}

void loop()
{
    rxPWM = pulseIn(rxPin, HIGH, 25000); // Kumanda sinyalini oku ve yorumla
    if(rxPWM < 1500) // Eğer rxPWM 1500'den küçükse kapat komutu geldi demektir yoksa açık komutu geldi demektir
    {
      ret_com = 0; // PWM 1.5 ms altında retract kapalı komutu
    }
    else
    {
      ret_com = 1; // PWM 1.5 ms üstünde retract açık komutu
    }  
    if(ret_com == 0 && ret_pos == 1) // Eğer retract açık ama kapat komutu geldiyse retractlar kapatılacak
    {
      RetractClose();
    }
    else if(ret_com == 1 && ret_pos == 0) // Eğer retract kapalı ama aç komutu geldiyse retractlar açılacak
    {
      RetractOpen();
    }
}


void RetractOpen() //Retractı açan subroutine
{
  digitalWrite(motor_l1, HIGH); // Retract motoru açma yönünde enerjilendirildi
  digitalWrite(motor_l2, LOW);
  sense = digitalRead(senspin);
//  cur_l = analogRead(sensor_l); Henüz akım kontrolü yapmıyoruz
  rxPWM = pulseIn(rxPin, HIGH, 25000);
//  while((cur_l < maxcur && cur_l > mincur) && rxPWM >= 1500) // Akım normal sınırlarda ve arada alıcıdan ters bir komut gelmediyse beklemede kalıyoruz
    while(rxPWM >= 1500 && sense == 1) // Buton kontrol ediliyor. Ayrıca alıcı sinyali de kontrol ediliyor. Çünkü arada ters sinyal gelmiş olabilir. Yani retract açılırken kapatmaya karar verebiliriz
  {
//    cur_l = analogRead(sensor_l);
    rxPWM = pulseIn(rxPin, HIGH, 25000);
    sense = digitalRead(senspin);
  }
  digitalWrite(motor_l1, LOW); // Ya butona basıldı ya da alıcıdan gelen komut değişti. Motoru durduruyoruz.
  ret_pos = !ret_pos; // Retract pozisyon değişkenini ters çeviriyoruz ve geri dönüyoruz.
// Bu subroutine'den geri döndüğümüzde eğer butona basılmış ise ret_pos ve ret_com aynı olacak. Alıcı sinyali değiştiyse farklı olacak. Dolayısıyla program hemen diğer subroutine'i çağıracak.
// Butona basılmış olması retractın istenilen pozisyona ulaştığı anlamına geliyor. Daha sonra buton işlevini akım sensörü ile değiştireceğiz.
}


void RetractClose() //Retractı kapatan subroutine
{
  digitalWrite(motor_l2, HIGH);
  digitalWrite(motor_l1, LOW);
  sense = digitalRead(senspin);
//  cur_l = analogRead(sensor_l);
  rxPWM = pulseIn(rxPin, HIGH, 25000);
//  while((cur_l < maxcur && cur_l > mincur) && rxPWM < 1500) // Akım normal sınırlarda ve arada alıcıdan ters bir komut gelmediyse beklemede kalıyoruz
  while(rxPWM < 1500 && sense == 1)
  {
//    cur_l = analogRead(sensor_l);
    rxPWM = pulseIn(rxPin, HIGH, 25000);
    sense = digitalRead(senspin);
  }
  digitalWrite(motor_l2, LOW);
  ret_pos = !ret_pos;

}

 

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Bu da bu akşam test edilecek, akım sensörlü kod...

int rxPin = 12; //Alıcı sinyali 12 nolu pinde
int motor_l1 = 3; // Sol retract motoru 3 ve 4 nolu pinlerde
int motor_l2 = 4;
int motor_r1 = 5; // Sağ retract motoru 5 ve 6 nolu pinlerde
int motor_r2 = 6;
int sensor_l = 1; // Sol akım sensörü 1 nolu analog girişte
int cur_l = 0; // Sol akım
int sensor_r = 2; // Sağ akım sensörü 2 nolu analog girişte
int cur_r = 0; // Sağ akım
int ret_com = 1; // Retract komutu Açık = 1 Kapalı = 0
int ret_pos = 1; // Aktüel retract pozisyonu Açık = 1, Kapalı = 0
int rxPWM = 0; //Alıcı sinyalini depolayan değişken
int x = 0; //Motor akım kontrolünde kullanılacak değişiken
int maxcur = 550; // Azami pozitif akım. Akım sensörüne ve motora göre bu değer değiştirilecek
int mincur = 470; // Azami negatif akım. Akım sensörüne ve motora göre bu değer değiştirilecek
int normcur1 = 530; // Beklenen normal pozitif akım. Akım sensörüne ve motora göre bu değer değiştirilecek
int normcur2 = 490; // Beklenen normal negatif akım. Akım sensörüne ve motora göre bu değer değiştirilecek


// Geçici değişkenler. Akım kontrolü devreye girince iptal edilecekler.
int senspin = 10; // Buton 10 numaralı digital girişe bağlı
int sense = 1; // Butona basıldığında LOW olan değişken




void setup()
{
  pinMode(motor_l1, OUTPUT);
  pinMode(motor_l2, OUTPUT);
  pinMode(motor_r1, OUTPUT);
  pinMode(motor_r2, OUTPUT);
  digitalWrite(motor_l1, LOW);
  digitalWrite(motor_l2, LOW);
  digitalWrite(motor_r1, LOW);
  digitalWrite(motor_r2, LOW);
  
  pinMode(senspin, INPUT); // Akım kontrolü devreye girince iptal edilecek.
  
  rxPWM = pulseIn(rxPin, HIGH, 25000);
  while(rxPWM < 800 || rxPWM > 2200) // Burada valid bir alıcı sinyali bekliyoruz
  {
    rxPWM = pulseIn(rxPin, HIGH, 25000);
  }
  if(rxPWM < 1500)
  {
    ret_com = 0; // PWM 1.5 ms altında retract kapalı komutu
  }
  else
  {
    ret_com = 1; // PWM 1.5 ms üstünde retract açık komutu
  }
}

void loop()
{
    rxPWM = pulseIn(rxPin, HIGH, 25000); // Kumanda sinyalini oku ve yorumla
    if(rxPWM < 1500) // Eğer rxPWM 1500'den küçükse kapat komutu geldi demektir yoksa açık komutu geldi demektir
    {
      ret_com = 0; // PWM 1.5 ms altında retract kapalı komutu
    }
    else
    {
      ret_com = 1; // PWM 1.5 ms üstünde retract açık komutu
    }  
    if(ret_com == 0 && ret_pos == 1) // Eğer retract açık konumdaysa ve kapat komutu geldiyse retractlar kapatılacak
    {
      RetractClose();
    }
    else if(ret_com == 1 && ret_pos == 0) // Eğer retract kapalı konumdaysa ve aç komutu geldiyse retractlar açılacak
    {
      RetractOpen();
    }
    
    // Retract komutu ile retract pozisyonu aynı ise herhangi bir şey yapılmadan loop'a devam edilecek
}


void RetractOpen() //Retractı açan subroutine
{
  digitalWrite(motor_l1, HIGH); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_l2, LOW);
  digitalWrite(motor_r1, HIGH); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_r2, LOW);
  x = 0;
//  sense = digitalRead(senspin);
  delay(250);
  cur_l = analogRead(sensor_l);
  cur_r = analogRead(sensor_r);
  if(cur_l < normcur1 && cur_l > normcur2) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_l1, LOW);
    x = x + 1;
  }
  if(cur_r < normcur1 && cur_l > normcur2) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_r1, LOW);
    x = x + 1;
  }
  while(x < 2)
  {
     rxPWM = pulseIn(rxPin, HIGH, 25000);
     cur_l = analogRead(sensor_l);
     cur_r = analogRead(sensor_r);
     if(cur_l > maxcur || cur_l < mincur)
     {
       digitalWrite(motor_l1, LOW);
       x = x + 1;
     }

     if(cur_r > maxcur || cur_r < mincur)
     {
       digitalWrite(motor_r1, LOW);
       x = x + 1;
     }
     if(rxPWM < 1500)
     {
       digitalWrite(motor_l1, LOW);
       digitalWrite(motor_r1, LOW);
       x = 2;
     }
  }
  
  ret_pos = !ret_pos; // Retract pozisyon değişkenini ters çeviriyoruz ve geri dönüyoruz.
  
// Bu subroutine'den geri döndüğümüzde eğer akım aşılmış ise ret_pos ve ret_com aynı olacak. Alıcı sinyali değiştiyse farklı olacak. Dolayısıyla program hemen diğer subroutine'i çağıracak.
}


void RetractClose() //Retractı kapatan subroutine
{
  digitalWrite(motor_l1, LOW); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_l2, HIGH);
  digitalWrite(motor_r1, LOW); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_r2, HIGH);
  x = 0;
//  sense = digitalRead(senspin);
  delay(250);
  cur_l = analogRead(sensor_l);
  cur_r = analogRead(sensor_r);
  if(cur_l < normcur1 && cur_l > normcur2) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_l2, LOW);
    x = x + 1;
  }
  if(cur_r < normcur1 && cur_l > normcur2) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_r2, LOW);
    x = x + 1;
  }
  while(x < 2)
  {
     rxPWM = pulseIn(rxPin, HIGH, 25000);
     cur_l = analogRead(sensor_l);
     cur_r = analogRead(sensor_r);
     if(cur_l > maxcur || cur_l < mincur)
     {
       digitalWrite(motor_l2, LOW);
       x = x + 1;
     }

     if(cur_r > maxcur || cur_r < mincur)
     {
       digitalWrite(motor_r2, LOW);
       x = x + 1;
     }
     if(rxPWM >= 1500)
     {
       digitalWrite(motor_l2, LOW);
       digitalWrite(motor_r2, LOW);
       x = 2;
     }
  }
  
  ret_pos = !ret_pos; // Retract pozisyon değişkenini ters çeviriyoruz ve geri dönüyoruz.
  
// Bu subroutine'den geri döndüğümüzde eğer akım aşılmış ise ret_pos ve ret_com aynı olacak. Alıcı sinyali değiştiyse farklı olacak. Dolayısıyla program hemen diğer subroutine'i çağıracak.
}

 

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Houston we have a problem!

Bu akşam öncelikle akım sensörünü test etmeye karar verdim. L293 motor sürücü entegresi ile breadboard üzerinde basit bir devre hazırladım. İki kontrol kablosu da 0 V'a bağlı. Birini ayırırsam motor bir yöne diğerini ayırırsam diğer yöne dönüyor. Burada sorun yok.

Sonra motor hattına akım sensörünü bağladım. Onu da Arduino'nun A0 analog girişine bağladım. Aşağıdaki basit programı kullanarak akım sensörü değerlerini okudum. Ne yazık ki sürekli değişen ve motorun ne çalışması ile ne de sıkışması ile anlamlı değişim gösteren değerler geldi. Şimdi aynı hatta bir de ampermetre bağlayıp deneyeceğim. Belki elimdeki minik motor yeterince akım çekemiyordur.

int voltaj = 0;
int minimum = 1024;
int maksimum = 0;


void setup()
{
  Serial.begin(9600);
}

void loop()
{
  voltaj = analogRead(0);
  if(voltaj > maksimum) maksimum = voltaj;
  if(voltaj < minimum) minimum = voltaj;
  Serial.print(voltaj);
  Serial.print("  ");
  Serial.print(minimum);
  Serial.print("  ");
  Serial.println(maksimum);
  delay(500);
}

 

[Zafer ŞAHİN]

Arduino ile Rectract - Iniş Takımı Uygulaması

Okuduğunuz değer aralığı nedir ? Akım sensörünü ve arduino'yu aynı (-) hattına bağladınız mı ?

 

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Elimdeki motor, 4.8 NiMh pil ile yüksüz çalışmada 90 - 120 mA akım çekiyor. Tam sıkıştırıp durdurunca 330 mA akım çekiyor. Kullandığım sensör ise burada daha önce konuştuğumuz 5A'lik sensör. Yani 5000 mA için 5V, 0 mA için 2.5 V ve ters yöndeki 5000 mA için de 0 V çıkış vermesi gerekiyor.
Bunun da analogRead karşılığının 5000 mA için 1023, 0 mA için 512 ve - 5000 mA için 0 integer değeri olması lazım.
Yaptığım testlerde motor bir yöne dönerken yüksüz 491, full stall halinde 481 değeri okudum. İşin ilginç yanı motorun ters dönüşünde okunan değer her durumda 495 - 505 arası oynadı. Yani motorun yüksüz dönüşü ya da stall oluşu ile alakalı bir değişiklik olmadı.

Şimdi...

+ ve - 5000 mA akımı yani totalde 10000 mA akımı 1024 (kolaylık olsun 1000 diyelim) adımda ölçebiliyorsak her bir analogRead adımı yaklaşık 10 mA'e denk gelir. 100 mA ile 300 mA arasındaki 200 mA'in karşılığı da 20 olur. Ama işin kötüsü, sistemin istirahat halindeki okumaları de en az bu kadar oynuyor. Yani tutarlı bir ölçüm ve sıkışma göstergesi oluşturur mu bilemiyorum. Tabii elimdeki motor minik bir motor. İlk fırsatta retractların kendi motorları ile denemem gerekiyor. Bu akşamlık bu kadar...

 

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Okuduğunuz değer aralığı nedir ? Akım sensörünü ve arduino'yu aynı (-) hattına bağladınız mı ?

Tabii, tüm sistem ortak şaseye sahip. Motor çalışmazken okuduğum değerler 495 - 510 arasında değişiyor sürekli.

 

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Her ne kadar "bu akşamlık bu kadar" desem de kaşıntı durmuyor.

Retract motorlarının aynısında bir tane yedeğim vardı. Onu bulup sisteme bağladım. Önce avometre ile ölçtüm. Yüksüz 250 mA çekiyor. Full stall olunca 750 mA oluyor akım. Yani değerler ilk motora göre belirgin olarak yüksek ve bunları ölçmek daha kolay olmalı.

Arduino ve sensör bağlantılarını yaptım. Motor çalışmazken okuduğum değerler 479 - 505 arasında oynuyor. Zaten sensörün datasheet'inde 21 mV noise demiş! Bu da 26 mV.
Motoru bir yöne çalıştırınca (300 mA) 471'e kadar iniyor. Motoru tam sıkıştırıp durdurunca (750 mA) okunan değer 450 oluyor.
Bu veriler fena değil. Kullanılabilir gibi. Ama başka bir sorun var ki kesinlikle anlamadım. Motoru ters tarafa çalıştırınca okunan değer motorun çalışmadığı zamanla aynı ve 479 - 500 arasında gidip geliyor. Daha da kötüsü motoru sıkıştırıp durdurunca da değişmiyor. Halbuki sensörün 0 mA üstü ve altı grafiği doğrusal. Bu davranışı çözemedim. Uygun bir sensör bulunamazsa bu proje yatar. O zaman endpoint switchleri gündeme gelir. Aslında kod belki de çok daha basitleşir ama mekanik gereklilikler artar. Bakalım...
Bu akşamlık gerçekten de bu kadar...

 

[Hakan Ülgenalp]

Arduino ile Rectract - Iniş Takımı Uygulaması

Senden bu işin çözümünü bekliyoruz Sümer abi , hatta bu işi standartlaştırıp , ekonomik ve kaliteli bir rectract sistemini piyasaya sürmeni de bekliyorum.Ama sen şimdi o fikri de beğenmezsin , çünkü pek çok konuyu bize göre defalarca aştığın için , sanırım sadece kendin için yaptığın ve çalıştığını gördüğün zaman hissettiğin mutluluk sana yeterli gelecektir.Ne yalan söyleyeyim,yine de seni hayranlıkla izlemek keyif veriyor........

 

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Ver gazı ver bakalım...
Bugün ameliyat yaparken bu konuyu epeyce düşündüm. Her bir retract için ayrı bir L293 sürücü kullanacağım ve akım sensörünü motor hattına değil entegrenin motor gerilimi hattına yani 8 No'lu bacağına bağlayacağım. Bu çekilde elde edeceğim en büyük avantaj negatif yöndeki akımlardan kurtulmak ve tek yönlü akım ile hesaplamaları kolaylaştırmak. Umarım bu akşam bunu deneyebilirim.
Haa sıfırdan retract tasarımına gelirsek... Evet bir gün bu da olacak ama ekonomik olmayacağı kesin. Bunca uykusuz gecenin ArGe bedelinin maliyete yansıması kaçınılmaz.

 

[Hakan Ülgenalp]

Arduino ile Rectract - Iniş Takımı Uygulaması

Ver gazı ver bakalım...
Bugün ameliyat yaparken bu konuyu epeyce düşündüm. Her bir retract için ayrı bir L293 sürücü kullanacağım ve akım sensörünü motor hattına değil entegrenin motor gerilimi hattına yani 8 No'lu bacağına bağlayacağım. Bu çekilde elde edeceğim en büyük avantaj negatif yöndeki akımlardan kurtulmak ve tek yönlü akım ile hesaplamaları kolaylaştırmak. Umarım bu akşam bunu deneyebilirim.
Haa sıfırdan retract tasarımına gelirsek... Evet bir gün bu da olacak ama ekonomik olmayacağı kesin. Bunca uykusuz gecenin ArGe bedelinin maliyete yansıması kaçınılmaz.

İşte profesyonel bir yaklaşım tarzı , farkımız bu abi , ben hep halimce kafayla düşünüyorum , oysa doğru yaklaşım bu , iyi iş iyi para

 

[Zafer ŞAHİN]

Arduino ile Rectract - Iniş Takımı Uygulaması

Bugün ameliyat yaparken bu konuyu epeyce düşündüm.

Sümer bey, ACS'ler ile yapılan uygulamalarda özellikle belirtilen bir husus daha var. ACS'lerin sensör katını besleyen kaynağın, mümkün olduğunca gürültüsüz olması gerektiğinden bahsediliyor. Şu anda aklıma gelen tek sorun bu... Eğer elinizde varsa, 100uF - 1000uF civarı bir kapasitörü ACS712nin 5v girişi ile GND girişi arasına takarak da deneyebilir misiniz ?

 

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Sümer bey, ACS'ler ile yapılan uygulamalarda özellikle belirtilen bir husus daha var. ACS'lerin sensör katını besleyen kaynağın, mümkün olduğunca gürültüsüz olması gerektiğinden bahsediliyor. Şu anda aklıma gelen tek sorun bu... Eğer elinizde varsa, 100uF - 1000uF civarı bir kapasitörü ACS712nin 5v girişi ile GND girişi arasına takarak da deneyebilir misiniz ?

Tamam onu denerim kolaylıkla. Aslında entegrenin 5. pini ile 0 V arasındaki kondansatörü büyüterek bant genişliğini kısıtlayıp (ki bizim bant genişliği ihtiyacımız yok) hassasiyetin artırılması mümkün. Ama sensor plaketinde bu kondansatör doğal olarak SMD!

 

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Önce sensor testleri...

Besleme hattında 1000 uF ile

Beklemede 480 - 507
Motor boşta çalışırken 450 - 489
Motor sıkışıp tam durunca 422 - 435

Besleme hattında 47 uF ile

Beklemede 456 - 471
Motor boşta çalışırken 431 - 460
Motor sıkışıp tam durunca 415 - 421

Çıkış hattında 1000 uF ile

Beklemede 486 - 490
Motor boşta çalışırken 469 - 480
Motor sıkışıp tam durunca 445 - 458

Çıkış hattında 47 uF ile

Beklemede 461 - 473
Motor boşta çalışırken 442 - 464
Motor sıkışıp tam durunca 435 - 438


Bunların içinde en çok aklıma yatanı sonuncusu yani çıkış hattına konulan 47 uF kondansatör ile elde edilen sonuç yattı. Bir sonraki mesajdaki denemede bunu kullandım.

 

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Birkaç test daha yaptıktan sonra normal akım karşılığı olarak 470 ve sıkışma akımı karşılığı olarak 420 değeri iyi gibi geldi. Aşağıdaki kodu kullandım. Kodda ufak bir değişiklik var. Şöyle ki tek motor olduğu için açma ya da kapatma altpogramına girişte X değeri doğrudan 1'den başlatılıyor.
Debugging amaçlı olarak çeşitli yerlere mesajlar serpiştirdim.

Kod şöyle:

int rxPin = 12; //Alıcı sinyali 12 nolu pinde
int motor_l1 = 3; // Sol retract motoru 3 ve 4 nolu pinlerde
int motor_l2 = 4;
int motor_r1 = 5; // Sağ retract motoru 5 ve 6 nolu pinlerde
int motor_r2 = 6;
int sensor_l = 1; // Sol akım sensörü 1 nolu analog girişte
int cur_l = 0; // Sol akım
int sensor_r = 2; // Sağ akım sensörü 2 nolu analog girişte
int cur_r = 0; // Sağ akım
int ret_com = 1; // Retract komutu Açık = 1 Kapalı = 0
int ret_pos = 1; // Aktüel retract pozisyonu Açık = 1, Kapalı = 0
int rxPWM = 0; //Alıcı sinyalini depolayan değişken
int x = 1; //Motor akım kontrolünde kullanılacak değişiken
int mincur = 420; // Azami negatif akım. Akım sensörüne ve motora göre bu değer değiştirilecek
int normcur = 470; // Beklenen normal pozitif akım. Akım sensörüne ve motora göre bu değer değiştirilecek


// Geçici değişkenler. Akım kontrolü devreye girince iptal edilecekler.
int senspin = 10; // Buton 10 numaralı digital girişe bağlı
int sense = 1; // Butona basıldığında LOW olan değişken




void setup()
{
  Serial.begin(9600);
  pinMode(motor_l1, OUTPUT);
  pinMode(motor_l2, OUTPUT);
  pinMode(motor_r1, OUTPUT);
  pinMode(motor_r2, OUTPUT);
  digitalWrite(motor_l1, LOW);
  digitalWrite(motor_l2, LOW);
  digitalWrite(motor_r1, LOW);
  digitalWrite(motor_r2, LOW);
  
  pinMode(senspin, INPUT); // Akım kontrolü devreye girince iptal edilecek.
  
  rxPWM = pulseIn(rxPin, HIGH, 25000);
  while(rxPWM < 800 || rxPWM > 2200) // Burada valid bir alıcı sinyali bekliyoruz
  {
    rxPWM = pulseIn(rxPin, HIGH, 25000);
  }
  if(rxPWM < 1500)
  {
    ret_com = 0; // PWM 1.5 ms altında retract kapalı komutu
  }
  else
  {
    ret_com = 1; // PWM 1.5 ms üstünde retract açık komutu
  }
  Serial.print("RET COM = ");
  Serial.print(ret_com);
  Serial.print("   RET POS = ");
  Serial.println(ret_pos);
  Serial.println("Setup tamam loopa gidiyoruz");
}

void loop()
{
    rxPWM = pulseIn(rxPin, HIGH, 25000); // Kumanda sinyalini oku ve yorumla
    if(rxPWM < 1500) // Eğer rxPWM 1500'den küçükse kapat komutu geldi demektir yoksa açık komutu geldi demektir
    {
      ret_com = 0; // PWM 1.5 ms altında retract kapalı komutu
    }
    else
    {
      ret_com = 1; // PWM 1.5 ms üstünde retract açık komutu
    }  
    if(ret_com == 0 && ret_pos == 1) // Eğer retract açık konumdaysa ve kapat komutu geldiyse retractlar kapatılacak
    {
      RetractClose();
    }
    else if(ret_com == 1 && ret_pos == 0) // Eğer retract kapalı konumdaysa ve aç komutu geldiyse retractlar açılacak
    {
      RetractOpen();
    }
    
    // Retract komutu ile retract pozisyonu aynı ise herhangi bir şey yapılmadan loop'a devam edilecek
}


void RetractOpen() //Retractı açan subroutine
{
  Serial.println("Retract Open");
  digitalWrite(motor_l2, LOW); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_l1, HIGH);
  digitalWrite(motor_r2, LOW); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_r1, HIGH);
  x = 1;
//  sense = digitalRead(senspin);
  delay(250);
  cur_l = analogRead(sensor_l);
  cur_r = analogRead(sensor_r);
  if(cur_l > normcur) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_l2, LOW);
    x = x + 1;
  }
  if(cur_l > normcur) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_r2, LOW);
    x = x + 1;
  }
  while(x < 2)
  {
     rxPWM = pulseIn(rxPin, HIGH, 25000);
     cur_l = analogRead(sensor_l);
     cur_r = analogRead(sensor_r);
     if(cur_l < mincur)
     {
       digitalWrite(motor_l2, LOW);
       x = x + 1;
     }

     if(cur_r < mincur)
     {
       digitalWrite(motor_r2, LOW);
       x = x + 1;
     }
     if(rxPWM >= 1500)
     {
       digitalWrite(motor_l2, LOW);
       digitalWrite(motor_r2, LOW);
       x = 2;
     }
  }
  
  digitalWrite(motor_l2, LOW);
  digitalWrite(motor_r2, LOW);
  ret_pos = 1; // Retract pozisyon değişkenini ters çeviriyoruz ve geri dönüyoruz.
  Serial.println("Retract Open Bitti");
  
// Bu subroutine'den geri döndüğümüzde eğer akım aşılmış ise ret_pos ve ret_com aynı olacak. Alıcı sinyali değiştiyse farklı olacak. Dolayısıyla program hemen diğer subroutine'i çağıracak.
}


void RetractClose() //Retractı kapatan subroutine
{
  Serial.println("Retract Close");
  digitalWrite(motor_l1, LOW); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_l2, HIGH);
  digitalWrite(motor_r1, LOW); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_r2, HIGH);
  x = 1;
//  sense = digitalRead(senspin);
  delay(250);
  cur_l = analogRead(sensor_l);
  cur_r = analogRead(sensor_r);
  if(cur_l > normcur) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_l2, LOW);
    x = x + 1;
  }
  if(cur_l > normcur) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_r2, LOW);
    x = x + 1;
  }
  while(x < 2)
  {
     rxPWM = pulseIn(rxPin, HIGH, 25000);
     cur_l = analogRead(sensor_l);
     cur_r = analogRead(sensor_r);
     if(cur_l < mincur)
     {
       digitalWrite(motor_l2, LOW);
       x = x + 1;
     }

     if(cur_r < mincur)
     {
       digitalWrite(motor_r2, LOW);
       x = x + 1;
     }
     if(rxPWM >= 1500)
     {
       digitalWrite(motor_l2, LOW);
       digitalWrite(motor_r2, LOW);
       x = 2;
     }
  }
  
  digitalWrite(motor_l2, LOW);
  digitalWrite(motor_r2, LOW);
  ret_pos = 0; // Retract pozisyon değişkenini ters çeviriyoruz ve geri dönüyoruz.
  Serial.println("Retract Close Bitti");  
// Bu subroutine'den geri döndüğümüzde eğer akım aşılmış ise ret_pos ve ret_com aynı olacak. Alıcı sinyali değiştiyse farklı olacak. Dolayısıyla program hemen diğer subroutine'i çağıracak.
}

Kapatma normal çalışıyor. Açma saçmalıyor. Ne oluyor anlatayım...

Başlagıçta buton açık konumda. Alıcıya güç gelince sisteme servo sinyali ulaşıyor ve setup aşaması geçiliyor. Burada sorun yok. Kapat komutu veriyorum. Retract Close altprogramına giriyor. Motor çalışıyor. Parmağımla iyice sıkıştırıp durduruyorum. "Retract Close Bitti" mesajı ile motor duruyor. Tam da olması gerektiği gibi.
Sonra aç komutu veriyorum. Retract Open altprogramına giriyor (mesaj veriyor). Motoru sıkıştırıyorum. "Retract Open Bitti" mesajı veriyor ama motor durmuyor.

Bir dakika bir dakika... Yanlış motor pinlerine LOW vermişim. Pardon... Sistemi topladım. Gece tekrar başına oturacağım. Şimdi devam edersem dayak geliyor hanımdan.

 

[Sumer Yamaner]

Arduino ile Rectract - Iniş Takımı Uygulaması

Akşam aşağıdaki kodu test edeceğim:

int rxPin = 12; //Alıcı sinyali 12 nolu pinde
int motor_l1 = 3; // Sol retract motoru 3 ve 4 nolu pinlerde
int motor_l2 = 4;
int motor_r1 = 5; // Sağ retract motoru 5 ve 6 nolu pinlerde
int motor_r2 = 6;
int sensor_l = 1; // Sol akım sensörü 1 nolu analog girişte
int cur_l = 0; // Sol akım
int sensor_r = 2; // Sağ akım sensörü 2 nolu analog girişte
int cur_r = 0; // Sağ akım
int ret_com = 1; // Retract komutu Açık = 1 Kapalı = 0
int ret_pos = 1; // Aktüel retract pozisyonu Açık = 1, Kapalı = 0
int rxPWM = 0; //Alıcı sinyalini depolayan değişken
int x = 1; //Motor akım kontrolünde kullanılacak değişiken
int mincur = 420; // Azami negatif akım. Akım sensörüne ve motora göre bu değer değiştirilecek
int normcur = 470; // Beklenen normal pozitif akım. Akım sensörüne ve motora göre bu değer değiştirilecek


// Geçici değişkenler. Akım kontrolü devreye girince iptal edilecekler.
int senspin = 10; // Buton 10 numaralı digital girişe bağlı
int sense = 1; // Butona basıldığında LOW olan değişken




void setup()
{
  Serial.begin(9600);
  pinMode(motor_l1, OUTPUT);
  pinMode(motor_l2, OUTPUT);
  pinMode(motor_r1, OUTPUT);
  pinMode(motor_r2, OUTPUT);
  digitalWrite(motor_l1, LOW);
  digitalWrite(motor_l2, LOW);
  digitalWrite(motor_r1, LOW);
  digitalWrite(motor_r2, LOW);
  
  pinMode(senspin, INPUT); // Akım kontrolü devreye girince iptal edilecek.
  
  rxPWM = pulseIn(rxPin, HIGH, 25000);
  while(rxPWM < 800 || rxPWM > 2200) // Burada valid bir alıcı sinyali bekliyoruz
  {
    rxPWM = pulseIn(rxPin, HIGH, 25000);
  }
  if(rxPWM < 1500)
  {
    ret_com = 0; // PWM 1.5 ms altında retract kapalı komutu
  }
  else
  {
    ret_com = 1; // PWM 1.5 ms üstünde retract açık komutu
  }
  Serial.print("RET COM = ");
  Serial.print(ret_com);
  Serial.print("   RET POS = ");
  Serial.println(ret_pos);
  Serial.println("Setup tamam loopa gidiyoruz");
}

void loop()
{
    rxPWM = pulseIn(rxPin, HIGH, 25000); // Kumanda sinyalini oku ve yorumla
    if(rxPWM < 1500) // Eğer rxPWM 1500'den küçükse kapat komutu geldi demektir yoksa açık komutu geldi demektir
    {
      ret_com = 0; // PWM 1.5 ms altında retract kapalı komutu
    }
    else
    {
      ret_com = 1; // PWM 1.5 ms üstünde retract açık komutu
    }  
    if(ret_com == 0 && ret_pos == 1) // Eğer retract açık konumdaysa ve kapat komutu geldiyse retractlar kapatılacak
    {
      RetractClose();
    }
    else if(ret_com == 1 && ret_pos == 0) // Eğer retract kapalı konumdaysa ve aç komutu geldiyse retractlar açılacak
    {
      RetractOpen();
    }
    
    // Retract komutu ile retract pozisyonu aynı ise herhangi bir şey yapılmadan loop'a devam edilecek
}


void RetractOpen() //Retractı açan subroutine
{
  Serial.println("Retract Open");
  digitalWrite(motor_l1, LOW); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_l2, HIGH);
  digitalWrite(motor_r1, LOW); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_r2, HIGH);
  x = 1;
//  sense = digitalRead(senspin);
  delay(250);
  cur_l = analogRead(sensor_l);
  cur_r = analogRead(sensor_r);
  if(cur_l > normcur) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_l1, LOW);
    x = x + 1;
  }
  if(cur_l > normcur) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_r1, LOW);
    x = x + 1;
  }
  while(x < 2)
  {
     rxPWM = pulseIn(rxPin, HIGH, 25000);
     cur_l = analogRead(sensor_l);
     cur_r = analogRead(sensor_r);
     if(cur_l < mincur)
     {
       digitalWrite(motor_l1, LOW);
       x = x + 1;
     }

     if(cur_r < mincur)
     {
       digitalWrite(motor_r1, LOW);
       x = x + 1;
     }
     if(rxPWM >= 1500)
     {
       digitalWrite(motor_l1, LOW);
       digitalWrite(motor_r1, LOW);
       x = 2;
     }
  }
  
  digitalWrite(motor_l1, LOW);
  digitalWrite(motor_r1, LOW);
  ret_pos = 1; // Retract pozisyon değişkenini ters çeviriyoruz ve geri dönüyoruz.
  Serial.println("Retract Open Bitti");
  
// Bu subroutine'den geri döndüğümüzde eğer akım aşılmış ise ret_pos ve ret_com aynı olacak. Alıcı sinyali değiştiyse farklı olacak. Dolayısıyla program hemen diğer subroutine'i çağıracak.
}


void RetractClose() //Retractı kapatan subroutine
{
  Serial.println("Retract Close");
  digitalWrite(motor_l1, LOW); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_l2, HIGH);
  digitalWrite(motor_r1, LOW); // Retract motorları açma yönünde enerjilendirildi
  digitalWrite(motor_r2, HIGH);
  x = 1;
//  sense = digitalRead(senspin);
  delay(250);
  cur_l = analogRead(sensor_l);
  cur_r = analogRead(sensor_r);
  if(cur_l > normcur) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_l2, LOW);
    x = x + 1;
  }
  if(cur_l > normcur) // Beklenen normal akım çekilmezse o kanalda retract bağlı olmayabilir. x değişkeni bir artırılır yani o kanalın işi bitti varsayılır
  {
    digitalWrite(motor_r2, LOW);
    x = x + 1;
  }
  while(x < 2)
  {
     rxPWM = pulseIn(rxPin, HIGH, 25000);
     cur_l = analogRead(sensor_l);
     cur_r = analogRead(sensor_r);
     if(cur_l < mincur)
     {
       digitalWrite(motor_l2, LOW);
       x = x + 1;
     }

     if(cur_r < mincur)
     {
       digitalWrite(motor_r2, LOW);
       x = x + 1;
     }
     if(rxPWM >= 1500)
     {
       digitalWrite(motor_l2, LOW);
       digitalWrite(motor_r2, LOW);
       x = 2;
     }
  }
  
  digitalWrite(motor_l2, LOW);
  digitalWrite(motor_r2, LOW);
  ret_pos = 0; // Retract pozisyon değişkenini ters çeviriyoruz ve geri dönüyoruz.
  Serial.println("Retract Close Bitti");  
// Bu subroutine'den geri döndüğümüzde eğer akım aşılmış ise ret_pos ve ret_com aynı olacak. Alıcı sinyali değiştiyse farklı olacak. Dolayısıyla program hemen diğer subroutine'i çağıracak.
}