lazer yer gÖsterici

[picusta]

Herkese kolay gelsin.
Şu sistemi yapmak istiyorum :
http://elm-chan.org/works/vlp/report_e.html
Sistemi daha basitleştirmek istiyorum, yapımı daha kolay ve ucuz olacak. Sistem istediğim konumda ufak bir şekil çizsin istiyorum (kare, üçgen veya daire), ayrıca icabında taşınabilir olacak.
- Modelcilik servosu kullanacağım. o yüzden kendim servo olayına girmeyeceğim, belki sistem daha yavaş olacak 50 FPS'ye ihtiyacım yok.
- işporta malı lazer anahatarlık kullanacağım.

[mihri]

Modelcilerin kullandığı servo ile olmaz gibi gelior bana. Ben daha önce benzer bişey yapmıştım. Birbirine dik eksenlerde hareket eden iki küçük aynayı aynı osilatör devresiyle titreşime sokmuştum ve sadece çember oluşturmuştum lazerle duvarda. Model servosu sürekli çizgi oluşturmak için yavaş kalabilir.

[picusta]

1) ilk önce CCS 'de delay_us fonksyonunu kullanarak servolari bir test edeyim dedim. O da ne, parkinsonlu gibi titriyor. Ya bu delay_us fonksyonu pek saglam degil veya CCS çok kötü kod ürettiyor.

2) Daha önce CCP'lerin PWM modunu kullanarak, 8 bit'ten biraz daha az çözünürlükle (), servolara komut sinyalini gönderiyordum  . Kod surada :
https://www.picproje.org/index.php/topic,16935.msg112199.html#msg112199

3) Bu sefer 2 modülü compare modda kullandim:
- Hersey kisa bir interrupt  rutininde bitiyor.diger isleri yapmak için bol vakit var
- 800us interrupt disable kalsa bile sinyal bozulmuyor.
- 20MHz kristal kullanilirsa 0.2us çözünürlük elde edilir.
- Multiplexer kullanip servo sayisi kolayca 20'ye çikabilir.(3ms / 30ms)
- Compare modülü daha çok olan bir PIC için sadece bir sabit'i degistirmek yeterli (biraz daha olabilir).

CCS proje (konya1 klasörü altinda) +
Proteus devresi (konya1/proteus simu klasörünün altinda) +
MPLAB Workbench, proteus simulasyonu yapmak için MPLAB'dan geçmekten baska yol bulamadim  (mplabccs klasörünün altinda)
Burada:
http://rapidshare.com/files/409048507/PICC.rar

Yapilacaklar :
- RS232 'dan gelen komutlari islemek ve servolari ona göre hareket ettirmek (menü veya PC programi).
- Mikro boy, hizli, dijital, ve yüksek hassasiyetli servo ile kullanmak.

1) Parkinsonlu kod :

#include "D:\PICC\Konya1\main.h"
#int_TIMER2
void  TIMER2_isr(void) 
{

}



#define LED PIN_C4  //CHANGE PIN_XX TO YOUR LED PIN NUMBER, EX: PIN_A5

void main()
{
int MsCpt;         // Compteur de Milisecondes
long Restantwidth;
long OffSetWidth;
   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_psp(PSP_DISABLED);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DIV_BY_16,255,1);
   setup_ccp1(CCP_PWM);
   set_pwm1_duty(153);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   enable_interrupts(INT_TIMER2);
   enable_interrupts(GLOBAL);

    //Example blinking LED program
    OffSetWidth = 0;
    while(true){
      OffSetWidth++;
      if (OffSetWidth>1000)
         {
         OffSetWidth=0;
         }
      for (MsCpt = 0; MsCpt<20; MsCpt++)
         {
         switch (MsCpt)
            {
            case 0:
               output_high(LED);
               delay_us(1000);
            break;
            case 1:
               delay_us(OffSetWidth);
               //delay_us(500);
               output_low(LED);
               //delay_us(500);
               Restantwidth = 1000 - OffSetWidth;
               delay_us(Restantwidth);
            break;
            default:
               output_low(LED);
               delay_us(1000);
            break;
            
            }
         }
    }

}

3) Sahane kod, bundan iyisi daha yazilmadi :

// includes
#include "D:\PICC\Konya1\main.h"


//Constantes
#define T_SIG_PERIOD  20000
#define T_MIN_SERVO   1000
#define T_MAX_SERVO   2500

// Enum
typedef enum
   {
   PPM_STATE_HIGH,
   PPM_STATE_LOW,
   }ENU_PPM_STATE;

typedef enum
   {
   SERVO1,
   SERVO2,
   MX_CCP,
   }ENU_SERVO;
   
   
// Global
volatile int  PPMState[MX_CCP];				// Durum

volatile long OffSetWidth[MX_CCP];   // Komut
volatile long CPPNextChange[MX_CCP];  // Sonraki 
volatile long CumulCcp[MX_CCP];	 	 // CCP'ye yazilacak Toplam, Timer1 sifirlanmiyor
volatile int  CPPFlag[MX_CCP];		// Ana program döngüsünü Haberdar et


void CompareFSM(int IdxCCP)
{
switch (PPMState[IdxCCP])
   {
   case  PPM_STATE_HIGH:
	   // bir sonraki seviye degisimini ayarla
	   if (IdxCCP==0)
      	setup_ccp1(CCP_COMPARE_SET_ON_MATCH);
	  else
		setup_ccp2(CCP_COMPARE_SET_ON_MATCH);

	  // Zamani hesapla ve durum degiskenini güncelle
      CPPNextChange[IdxCCP]  = T_SIG_PERIOD - CPPNextChange[IdxCCP];
  	  CumulCcp[IdxCCP] = CumulCcp[IdxCCP] + CPPNextChange[IdxCCP];
	  PPMState[IdxCCP] = PPM_STATE_LOW;
	  // SFR'e yaz
 	   if (IdxCCP==0)
       	CCP_1 = CumulCcp[IdxCCP];
	   else
		CCP_2 = CumulCcp[IdxCCP];
      break;
   case  PPM_STATE_LOW:
	   // bir sonraki seviye degisimini ayarla
	   if (IdxCCP==0)
      	setup_ccp1(CCP_COMPARE_CLR_ON_MATCH);
	  else
		setup_ccp2(CCP_COMPARE_CLR_ON_MATCH);

	  // Zamani hesapla ve durum degiskenini güncelle
	  CPPNextChange[IdxCCP] = T_MIN_SERVO + OffSetWidth[IdxCCP];
      if (CPPNextChange[IdxCCP] > T_MAX_SERVO)
          {
          CPPNextChange[IdxCCP] = T_MAX_SERVO;
          }
	   CumulCcp[IdxCCP] = CumulCcp[IdxCCP] + CPPNextChange[IdxCCP];
       PPMState[IdxCCP] = PPM_STATE_HIGH;
       // SFR'e yaz
 	   if (IdxCCP==0)
       	CCP_1 = CumulCcp[IdxCCP];
	   else
		CCP_2 = CumulCcp[IdxCCP];
      break;
	default :
		break;
   }
CPPFlag[IdxCCP] = 1;
}

#int_ccp1
void compare1_isr()
{
CompareFSM(0);
}

#int_ccp2
void compare2_isr()
{
CompareFSM(1);
}



void main()
{
int ii;

   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_psp(PSP_DISABLED);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_INTERNAL);
   setup_timer_2(T2_DIV_BY_16,255,1);
   setup_ccp1(CCP_COMPARE_CLR_ON_MATCH);
   setup_ccp2(CCP_COMPARE_CLR_ON_MATCH);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);


    // CCP setup
    setup_ccp1(CCP_COMPARE_SET_ON_MATCH);    // Configure CCP1 to set
    CCP_1=0;                                 // C2 high now
    setup_ccp2(CCP_COMPARE_SET_ON_MATCH);    // Configure CCP1 to set
    CCP_2=0;                                 // C2 high now
    set_timer1(0);
    CCP_1 = T_MIN_SERVO;
    CCP_2 = T_MIN_SERVO;
    setup_ccp1(CCP_COMPARE_CLR_ON_MATCH);
    setup_ccp2(CCP_COMPARE_CLR_ON_MATCH);
    
    // State Machine
	for (ii = 0; ii < MX_CCP; ii++)
		{
	    PPMState[ii] = PPM_STATE_HIGH;
	    CPPFlag[ii] = 0;
	    CPPNextChange[ii] = T_SIG_PERIOD - T_MIN_SERVO;
	    OffSetWidth[ii] = 0;
		CumulCcp[ii] = 0;
		}
	
    
    // Enable interrupt
   enable_interrupts(INT_CCP1);
   enable_interrupts(INT_CCP2);
   enable_interrupts(GLOBAL);
   
    while(true)
      {
	   // Servolara yeni komutlari yolla
	 for (ii = 0; ii<MX_CCP; ii++)
		{
	      if (CPPFlag[ii])
	         {
	         CPPFlag[ii] = 0;
	         switch (PPMState[ii])
	            {
	            case PPM_STATE_HIGH :
				   if (ii)
						OffSetWidth[ii]++;
					else
				   		OffSetWidth[ii]= OffSetWidth[ii] + 10;
					if (OffSetWidth[ii] > ( T_MAX_SERVO - T_MIN_SERVO) )
					   OffSetWidth[ii] =0;
	               break;
	            case PPM_STATE_LOW :
	               break; 
	            }
	         }

		}
	  // Seri 'den veri geldimi, yorumla
      } // Ana döndü son
}  // Main Son

NOT:
Deplasmanda oldugum için konya sokaktan (ULUS/ANKARA) malzeme temin etmek zorunda kaldim, o yüzden mikroislemci secimim PIC oldu.
Dediler, sezon bitti, artik PIC gelistirme karti bulunmuyor, hakkikaten hiçbir dükkanda yok(en az 10 pic satan yere sordum). Sonunda bir dükkandan programlayici, malzeme ve Bread bord aldim. Bread bord kalitesiz çikti, gerilim bölücü direnç, açik devre, kisa devre ne ararsan var, dogrudan çöpe gitti.
Herkes gider mersin'e ben giderim tersine misali (veya at - esek): ARM - DSP'den PIC'e, Texas Instrument CCS 'inden CCS Info'ya geçis oldu.

Daha önce CCS kullanmamistim, ilk projem oldu.  Proteus'u daha önce bir kere denemistim,  örnek simülasyon çalistirmistim.
Forum'daki bilgiler sayesinde (KAZIM hocanin proteus linkleri ) programi CCS'de yazip proteus'ta simule edebildim (kurulmasi, ayarlamasi epey bi ugrastirdi gerçi, simulasyon için MPLAB yüklemek mecburiyetinde kaldim, .COF ile proteus hata veriyordu).
Yarin Antalya'ya 1 haftaligina gidiyorum, o yüzden hemen cevap yazamiyacagim.
Geç saatte mesaj yazdigim için olabilecek hatalardan dolayi simdiden özür.

[serdararikan]

bu iş  RC servolar ile olmaz.galvo yu yapabilrisen bu işi yapabilirsin.bende bi aralar bu siteyi incelemiştim.galvo kısmı çok zor bence çok hassas bi uygulama.ama imkansız yoktur.

[sezgin05]

Serdararıkan haklı RC servo,step motor veya servo bu iş için çok yavaş kalır.Galvo tek çözüm bencede...

[z]

Ne oldu bu proje?

Projede kullanilan posizyon sensorune ait semada (c sikki) bir kapasitor var.

http://elm-chan.org/works/vlp/pd.png

Bu kapasitorun amaci hakkinda ne dusunuyorsunuz?

[picusta]

Daha sonra yorum yazarim.

Simulasyon, CCS ve MPLAB proje + kod :
http://rapidshare.com/files/430279211/PICC.rar

//*************************
// includes
#include "main.h"



//*************************
// Sabitler
//
#define T_SIG_PERIOD             20000
#define T_MIN_SERVO              800
#define T_MAX_SERVO              2500
#define SERIALDATA_BUFFER_SIZE   32
#define BUFFER_SIZE              32
#define FRAME_START              'B'
#define FRAME_SEPARATOR          'X'
#define FRAME_END                'Z'
#define MAX_INT_LENGTH           4



//*****************************
// Enum (enumeration)
// 

// ENU_PPM_STATE
// PPM  çikis durumu
typedef enum
   {
   PPM_STATE_HIGH,
   PPM_STATE_LOW,
   }ENU_PPM_STATE;

// ENU_SERVO
// Servolar
typedef enum
   {
   SERVO1,
   SERVO2,
   MX_SERVO,
   }ENU_SERVO;
   
//
// ENU_RX_STATE
// Gelen veriyi çözme durum makinesi. 
typedef enum
   {
   RX_STATE_START,   // Start karakteri beklenir
   RX_STATE_FIRST,   // Birinci deger aliniyor
   RX_STATE_SECOND,  // ikinci deger aliniyor
   RX_STATE_END,     // Son deger alindi, komut servolara gönderilmeli
   }ENU_RX_STATE;
   
   

   
//*************************************
/////Veri tipleri
//
// 
// STR_SERIALDATA
// Interrupt -> Ana program  Seri data Alimi
typedef struct
{
BYTE buffer[BUFFER_SIZE];   // Buffer
BYTE next_in;               // Yazma Pointeri
BYTE next_out;             // Okuma pointeri
}STR_SERIALDATA;


// STR_INTERPRETED_SERDATA
typedef struct
{
ENU_RX_STATE  Durum;       // Durum makinesinin durumu
long Val[MX_SERVO];          // PPM Komut degerleri
char Buff[BUFFER_SIZE];    // Geçici tampon bellek
int IdxBuff;               // Tampon bellek durumu
}STR_INTERPRETED_SERDATA;




// *******************************************************
// Global degiskenler
volatile int  PPMState[MX_SERVO];              // Durum
volatile long OffSetWidth[MX_SERVO];           //  PPM Komut
volatile long CPPNextChange[MX_SERVO];         // Sonraki 
volatile long CumulCcp[MX_SERVO];              // CCP'ye yazilacak Toplam, Timer1 sifirlanmiyor
volatile int  CPPFlag[MX_SERVO];               // Ana program döngüsünü Haberdar et
volatile STR_INTERPRETED_SERDATA  SeriYorum; // Seri bilgilerin yorumu


// *******************************************************************
// MACRO LAr 
#define bkbhit (SeriYorum.IdxBuff!=0)



// ****************************************************************
// Prototipler
void CompareFSM(ENU_SERVO IdxCCP);

void SeriDekod(char RxChar);
   int RakamYorumla(char RxChar,ENU_SERVO ServoIdx,ENU_RX_STATE SonrakiDurum,char BeklenenChar );
   void ResetSeriYorum();
   int TestInt(char carac);
   long StringToLong(char *Buff, int length);
// *******************************************************************
// interrupt rutinleri

//
// compare1_isr
// CCP 1 compare ISR
#int_ccp1
void compare1_isr()
{
CompareFSM(SERVO1);
}

//
// compare2_isr
// CCP 2 compare ISR
#int_ccp2
void compare2_isr()
{
CompareFSM(SERVO2);
}

//
// serial_isr
// Seri ISR
#int_rda
void serial_isr() {
 
   SeriDekod(getc());

}

// *********************************************************************
// Fonksyonlar

// 
// CompareFSM
// PPM üretmeyi saglayan durum makinesi
//  Parametre : 
//   giris : IdxCCP  PPM çikis (servo) numarasi
void CompareFSM(ENU_SERVO IdxCCP)
{
switch (PPMState[IdxCCP])
   {
   case  PPM_STATE_HIGH:
      // bir sonraki seviye degisimini ayarla
      if (IdxCCP==SERVO1)
         setup_ccp1(CCP_COMPARE_SET_ON_MATCH);
     else
      setup_ccp2(CCP_COMPARE_SET_ON_MATCH);

     // Zamani hesapla ve durum degiskenini güncelle
      CPPNextChange[IdxCCP]  = T_SIG_PERIOD - CPPNextChange[IdxCCP];
       CumulCcp[IdxCCP] = CumulCcp[IdxCCP] + CPPNextChange[IdxCCP];
     PPMState[IdxCCP] = PPM_STATE_LOW;
     // SFR'e yaz
       if (IdxCCP==SERVO1)
          CCP_1 = CumulCcp[IdxCCP];
      else
      CCP_2 = CumulCcp[IdxCCP];
      break;
   case  PPM_STATE_LOW:
      // bir sonraki seviye degisimini ayarla
      if (IdxCCP==SERVO1)
         setup_ccp1(CCP_COMPARE_CLR_ON_MATCH);
     else
      setup_ccp2(CCP_COMPARE_CLR_ON_MATCH);

     // Zamani hesapla ve durum degiskenini güncelle
     CPPNextChange[IdxCCP] = T_MIN_SERVO + OffSetWidth[IdxCCP];
      if (CPPNextChange[IdxCCP] > T_MAX_SERVO)
          {
          CPPNextChange[IdxCCP] = T_MAX_SERVO;
          }
      CumulCcp[IdxCCP] = CumulCcp[IdxCCP] + CPPNextChange[IdxCCP];
       PPMState[IdxCCP] = PPM_STATE_HIGH;
       // SFR'e yaz
       if (IdxCCP==SERVO1)
          CCP_1 = CumulCcp[IdxCCP];
      else
      CCP_2 = CumulCcp[IdxCCP];
      break;
   default :
      break;
   }
CPPFlag[IdxCCP] = 1;
}


//
// SeriDekod
// Seri baglantidan gelen karakterleri çöz
void SeriDekod(char RxChar)
{
// Duruma göre islem
switch (SeriYorum.Durum)
   {
   case RX_STATE_START :    // Start karakteri beklenir
      if  (RxChar == FRAME_START)
         {
         // Durumu ilerlet
         SeriYorum.Durum = RX_STATE_FIRST;
         }
      break;
   case RX_STATE_FIRST :   // Birinci deger aliniyor
         RakamYorumla(RxChar, SERVO1,RX_STATE_SECOND, FRAME_SEPARATOR );   
         
         break;
   case RX_STATE_SECOND :  // ikinci deger aliniyor
       if (RakamYorumla(RxChar, SERVO2,RX_STATE_END, FRAME_END ))
          {
          // Komutlari ana döngüden al gönder
          }
      break;
   case RX_STATE_END :     // Son deger alindi,
      // komut servolara gönderilmeli, ama gönderilmemis ? bisey yapma, 
      // ana döngünün yapmasini bekle
      break;
   }
   

}


//
// ResetSeriYorum
//  Seri Yorum Struct'unu sifirliyor
void ResetSeriYorum()
{
SeriYorum.Durum = RX_STATE_START;
SeriYorum.IdxBuff = 0;
}


//
// RakamYorumla
// Rakam beklenen durumlarda rakami yorumlar
// giris :
//   RxChar : alinan karakter
//   ServoIdx : Hangi çikisin degeri
//   SonrakiDurum: testler basarili olursa geçilecek sonraki durum
//   BeklenenChar: Bir sonraki duruma geçmek için beklenen karakter (testler basarili olursa o da)
// dönüs : 
//   Eger bir sonraki duruma geçildiyse 0'dan baska, yoksa 0
int RakamYorumla(char RxChar,ENU_SERVO ServoIdx,ENU_RX_STATE SonrakiDurum,char BeklenenChar )
{
int Retour;
Retour = 0;

if (TestInt(RxChar))  // Rakam alindi
   {
   if (SeriYorum.IdxBuff > MAX_INT_LENGTH)  // 10 000 ms veya daha  büyük sayi kabul etmiyoruz
      {
      //  hata Baslangica geri dön
      ResetSeriYorum();
      }
   else
      {
      // Rakami (harf) hafizaya al
      SeriYorum.Buff[SeriYorum.IdxBuff] = RxChar;
      // Index ilerlet
      SeriYorum.IdxBuff++;
      }  
   }
else if ( RxChar == BeklenenChar )
   {
   if (SeriYorum.IdxBuff == 0) // En az bir rakam olmasi gerek
      {
      // Hata : sil bastan
      ResetSeriYorum();   
      }
   else
      {
      // Servo degerini kaydet
      SeriYorum.Val[ServoIdx] = StringToLong(SeriYorum.Buff, SeriYorum.IdxBuff);
      // Degeri test et
      if (SeriYorum.Val[ServoIdx] > (T_MAX_SERVO - T_MIN_SERVO))
         {
         //  hata Baslangica geri dön
         ResetSeriYorum();
         }
      else
         {
         // OK OK
         Retour = 1;
         // Tamponu sifirla (yeni degeri hafizaya almak için)
         SeriYorum.IdxBuff = 0;
         // Durumu ilerlet
         SeriYorum.Durum = SonrakiDurum;
         }
      }
   }
else
   {//  hata Baslangica geri dön
   ResetSeriYorum();
   }
return Retour;
}



   
//
// StringToLong
// Karakter katarindan sayiya çeviren fonksyon
long StringToLong(char *Buff, int length)
{
long Retour;
long Basamak;
signed int ii;

Retour = 0;
Basamak = 1;
for (ii = length- 1 ;ii >= 0; ii--)
   {
   Retour = Basamak * (Buff[ii]- '0') + Retour;
   Basamak = Basamak * 10;
   }
   

return Retour;
}


//
// TestInt
// Bir karakterin Rakam olup olmadigini test ediyor
int TestInt(char carac)
{
int Retour;

if (carac >= '0' && carac <= '9')
   {
   Retour = 1;
   }
else
   Retour = 0;

return Retour;
}

// **********************************************
// Ana döngü 
//
void main()
{
int ii;     // döngü Sayaci

long Komut[MX_SERVO]; // Servolara göndrilecek komut
int KomutGonder[MX_SERVO];   // Komut gönder

   // Hardware setup
   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_psp(PSP_DISABLED);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_INTERNAL);
   setup_timer_2(T2_DIV_BY_16,255,1);
   setup_ccp1(CCP_COMPARE_CLR_ON_MATCH);
   setup_ccp2(CCP_COMPARE_CLR_ON_MATCH);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);


    // CCP setup
    setup_ccp1(CCP_COMPARE_SET_ON_MATCH);    // Configure CCP1 to set
    CCP_1=0;                                 // C2 high now
    setup_ccp2(CCP_COMPARE_SET_ON_MATCH);    // Configure CCP1 to set
    CCP_2=0;                                 // C2 high now
    set_timer1(0);
    CCP_1 = T_MIN_SERVO;
    CCP_2 = T_MIN_SERVO;
    setup_ccp1(CCP_COMPARE_CLR_ON_MATCH);
    setup_ccp2(CCP_COMPARE_CLR_ON_MATCH);
    
    //
    //********************************
    // DEgiskenleri sifirla
    
    // CCP State Machine
   for (ii = 0; ii < MX_SERVO; ii++)
      {
       PPMState[ii] = PPM_STATE_HIGH;
       CPPFlag[ii] = 0;
       CPPNextChange[ii] = T_SIG_PERIOD - T_MIN_SERVO;
       OffSetWidth[ii] = 0;
      CumulCcp[ii] = 0;
      }
   
   // SeriYorum durum makinesi sifirlansin
   ResetSeriYorum();
   
   // Ana döngü degiskenlerini sifirla
   for (ii= 0; ii < MX_SERVO; ii++)
      {
      KomutGonder[ii] = 0;
      }
    
    // Enable interrupt
   enable_interrupts(INT_CCP1);
   enable_interrupts(INT_CCP2);
	enable_interrupts(int_rda);
   enable_interrupts(GLOBAL);
   
   
   // Ana döngü
    while(true)
      {
      
      
      // Seriden veri geldi mi ? 
      if (SeriYorum.Durum == RX_STATE_END)
         {
         // Komutlari seri modülden ana programa aktar
         for (ii = 0 ; ii< MX_SERVO; ii++) 
            {
            Komut[ii]  = SeriYorum.Val[ii];
            KomutGonder[ii] = 1;
            }
         ResetSeriYorum();
         }
         
      
      
      // Servolari tara
      for (ii = 0; ii<MX_SERVO; ii++)
        {
        // Servolar komut almaya hazir
         if (CPPFlag[ii])
            {
            // Yeni komut 
            if (KomutGonder[ii])
               {
               OffSetWidth[ii] = Komut[ii];
               KomutGonder[ii] = 0;
               }
            CPPFlag[ii] = 0;
            }
         }
     
      } // Ana döngü son
}  // Main Son