Arduino
OKUDUĞUNUZ KONU
Resim Çizen Robot Kol Yapımı (Arduino+Matlab)
80

Resim Çizen Robot Kol Yapımı (Arduino+Matlab)

Yazar : Sezgin Gül30 Haziran 2015

Resim çizen robot kol matlab resim işleme ile fotoğrafımızı matlaba kaydederek arduino üzerinden robot kol tarafından resmimizi çizdireceğiz.Daha önceden robot kol bir şeyler taşımak kaldırmak için tasarlanmıştı bu projede ise robot kol resim çizmek için kullanılmakta.Matlab ile arduino arasındaki haberleşme sayesinde arduino üzerinden servo motorlarlar sürülebiliyor.

Bunun için öncelikle matlab arduino haberleşmesini yapmamız gerekiyor.

Malzemeler:

  1. Arduino uno
  2. 3 Adet 7 kg tork servo motor
  3. Mekaniği için lego kullanabilirsiniz
  4. 2 Adet sarhoş tekerlek

Matlab’den arduinoya bağlanmak için öncelikle adioes.ino dosyasını arduinıya atın daha sonra arduino.m matlab dosyasını çalıştırın ve arduinoya bağlanmasını bekleyin.Bağlandıktan sonra finaldraw.m dosyasını açın burada fotoğrafı çizilecek olan resmin adının yazılı olduğu satır var.Siz fotoğrafınızın adını oradaki satıra yazın.Fotoğrafınızı da matlab klasörüne atın.

Matlab’a resim gönderme ve koda resim tanımlamayı aşağıdaki şekilde yapabilirsiniz.

Arduino ve matlab yazılımın aşağıdaki linkten indirebilirsiniz.Yukarıda resimlerde belirtilen yerlerde düzenlemeler yapmanız gerekiyor.Matlaba resim yükleme yaptığınızda resim işlenerek kara kalem formatına dönüştürülüyor yani çizgisel bir formatta olur ve arduino bu çizgileri algılayarak üzerinden geçiyor.

Projenin Kodlarını İndir

Robot kolun devre şeması, mekaniği ve boyutları aşağıdaki şekillerde gösterilmiştir.Mekanik kısmını birebir aynı yapmanız gerekli çünkü program bu ölçülere göre ayarlanmış.İlk servo motor ile ikinci servo motor arasındaki uzaklık 20cm olmalıdır.İkinci servo motor ile kalem arasındaki uzaklıkta 20 cm olmalıdır.Bu ölçülere çok dikkat etmeniz gerekir.

#include <Servo.h>

/* define internal for the MEGA as 1.1V (as as for the 328)  */
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define INTERNAL INTERNAL1V1
#endif

/* define encoder structure                                  */
typedef struct { int pinA; int pinB; int pos; int del;} Encoder;    
volatile Encoder Enc[3] = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}};

/* create servo vector                                       */
Servo servo[70];

void setup() {
  /* initialize serial                                       */
  Serial.begin(115200);
}


void loop() {
  
  /* variables declaration and initialization                */
  
  static int  s   = -1;    /* state                          */
  static int  pin = 13;    /* generic pin number             */
  static int  enc = 0;     /* generic encoder number         */
 
  int  val =  0;           /* generic value read from serial */
  int  agv =  0;           /* generic analog value           */
  int  dgv =  0;           /* generic digital value          */


  /* The following instruction constantly checks if anything 
     is available on the serial port. Nothing gets executed in
     the loop if nothing is available to be read, but as soon 
     as anything becomes available, then the part coded after 
     the if statement (that is the real stuff) gets executed */

  if (Serial.available() >0) {

    /* whatever is available from the serial is read here    */
    val = Serial.read();
    
    /* This part basically implements a state machine that 
       reads the serial port and makes just one transition 
       to a new state, depending on both the previous state 
       and the command that is read from the serial port. 
       Some commands need additional inputs from the serial 
       port, so they need 2 or 3 state transitions (each one
       happening as soon as anything new is available from 
       the serial port) to be fully executed. After a command 
       is fully executed the state returns to its initial 
       value s=-1                                            */

    switch (s) {

      
      /* s=-1 means NOTHING RECEIVED YET ******************* */
      case -1:      

      /* calculate next state                                */
      if (val>47 && val<90) {
	  /* the first received value indicates the mode       
           49 is ascii for 1, ... 90 is ascii for Z          
           s=0 is change-pin mode;
           s=10 is DI;  s=20 is DO;  s=30 is AI;  s=40 is AO; 
           s=50 is servo status; s=60 is aervo attach/detach;  
           s=70 is servo read;   s=80 is servo write;
           s=90 is query script type (1 basic, 2 motor);
           s=210 is encoder attach; s=220 is encoder detach;
           s=230 is get encoder position; s=240 is encoder reset;
           s=250 is set encoder debounce delay;
           s=340 is change analog reference;
           s=400 example echo returning the input argument;
                                                             */
        s=10*(val-48);
      }
      
      /* the following statements are needed to handle 
         unexpected first values coming from the serial (if 
         the value is unrecognized then it defaults to s=-1) */
      if ((s>90 && s<210) || (s>250 && s!=340 && s!=400)) {
        s=-1;
      }

      /* the break statements gets out of the switch-case, so
      /* we go back and wait for new serial data             */
      break; /* s=-1 (initial state) taken care of           */


     
      /* s=0 or 1 means CHANGE PIN MODE                      */
      
      case 0:
      /* the second received value indicates the pin 
         from abs('c')=99, pin 2, to abs('¦')=166, pin 69    */
      if (val>98 && val<167) {
        pin=val-97;                /* calculate pin          */
        s=1; /* next we will need to get 0 or 1 from serial  */
      } 
      else {
        s=-1; /* if value is not a pin then return to -1     */
      }
      break; /* s=0 taken care of                            */


      case 1:
      /* the third received value indicates the value 0 or 1 */
      if (val>47 && val<50) {
        /* set pin mode                                      */
        if (val==48) {
          pinMode(pin,INPUT);
        }
        else {
          pinMode(pin,OUTPUT);
        }
      }
      s=-1;  /* we are done with CHANGE PIN so go to -1      */
      break; /* s=1 taken care of                            */
      


      /* s=10 means DIGITAL INPUT ************************** */
      
      case 10:
      /* the second received value indicates the pin 
         from abs('c')=99, pin 2, to abs('¦')=166, pin 69    */
      if (val>98 && val<167) {
        pin=val-97;                /* calculate pin          */
        dgv=digitalRead(pin);      /* perform Digital Input  */
        Serial.println(dgv);       /* send value via serial  */
      }
      s=-1;  /* we are done with DI so next state is -1      */
      break; /* s=10 taken care of                           */

      

      /* s=20 or 21 means DIGITAL OUTPUT ******************* */
      
      case 20:
      /* the second received value indicates the pin 
         from abs('c')=99, pin 2, to abs('¦')=166, pin 69    */
      if (val>98 && val<167) {
        pin=val-97;                /* calculate pin          */
        s=21; /* next we will need to get 0 or 1 from serial */
      } 
      else {
        s=-1; /* if value is not a pin then return to -1     */
      }
      break; /* s=20 taken care of                           */

      case 21:
      /* the third received value indicates the value 0 or 1 */
      if (val>47 && val<50) {
        dgv=val-48;                /* calculate value        */
	digitalWrite(pin,dgv);     /* perform Digital Output */
      }
      s=-1;  /* we are done with DO so next state is -1      */
      break; /* s=21 taken care of                           */


	
      /* s=30 means ANALOG INPUT *************************** */
      
      case 30:
      /* the second received value indicates the pin 
         from abs('a')=97, pin 0, to abs('p')=112, pin 15    */
      if (val>96 && val<113) {
        pin=val-97;                /* calculate pin          */
        agv=analogRead(pin);       /* perform Analog Input   */
	Serial.println(agv);       /* send value via serial  */
      }
      s=-1;  /* we are done with AI so next state is -1      */
      break; /* s=30 taken care of                           */



      /* s=40 or 41 means ANALOG OUTPUT ******************** */
      
      case 40:
      /* the second received value indicates the pin 
         from abs('c')=99, pin 2, to abs('¦')=166, pin 69    */
      if (val>98 && val<167) {
        pin=val-97;                /* calculate pin          */
        s=41; /* next we will need to get value from serial  */
      }
      else {
        s=-1; /* if value is not a pin then return to -1     */
      }
      break; /* s=40 taken care of                           */


      case 41:
      /* the third received value indicates the analog value */
      analogWrite(pin,val);        /* perform Analog Output  */
      s=-1;  /* we are done with AO so next state is -1      */
      break; /* s=41 taken care of                           */
      
      
      
      /* s=50 means SERVO STATUS (ATTACHED/DETACHED) ******* */
      
      case 50:
      /* the second value indicates the servo attachment pin
         from abs('c')=99, pin 2, to abs('¦')=166, pin 69    */
      if (val>98 && val<167) {
        pin=val-97;                /* calculate pin          */
        dgv=servo[pin].attached();            /* read status */
        Serial.println(dgv);       /* send value via serial  */
      }
      s=-1;  /* we are done with servo status so return to -1*/
      break; /* s=50 taken care of                           */
      


      /* s=60 or 61 means SERVO ATTACH/DETACH ************** */
      
      case 60:
      /* the second value indicates the servo attachment pin
         from abs('c')=99, pin 2, to abs('¦')=166, pin 69    */
      if (val>98 && val<167) {
        pin=val-97;                /* calculate pin          */
        s=61; /* next we will need to get 0 or 1 from serial */
      } 
      else {
        s=-1; /* if value is not a servo then return to -1   */
      }
      break; /* s=60 taken care of                           */


      case 61:
      /* the third received value indicates the value 0 or 1 
         0 for detach and 1 for attach                       */ 
      if (val>47 && val<50) {
        dgv=val-48;                /* calculate value        */
        if (dgv) servo[pin].attach(pin);     /* attach servo */
        else servo[pin].detach();            /* detach servo */
      }
      s=-1;  /* we are done with servo attach/detach so -1   */
      break; /* s=61 taken care of                           */



      /* s=70 means SERVO READ ***************************** */
      
      case 70:
      /* the second value indicates the servo attachment pin
         from abs('c')=99, pin 2, to abs('¦')=166, pin 69    */
      if (val>98 && val<167) {
        pin=val-97;                /* calculate pin          */
        agv=servo[pin].read();     /* read value             */
	Serial.println(agv);       /* send value via serial  */
      }
      s=-1;  /* we are done with servo read so go to -1 next */
      break; /* s=70 taken care of                           */



      /* s=80 or 81 means SERVO WRITE   ******************** */
      
      case 80:
      /* the second value indicates the servo attachment pin
         from abs('c')=99, pin 2, to abs('¦')=166, pin 69    */
      if (val>98 && val<167) {
        pin=val-97;                /* calculate pin          */
        s=81; /* next we will need to get value from serial  */
      }
      else {
        s=-1; /* if value is not a servo then return to -1   */
      }
      break; /* s=80 taken care of                           */


      case 81:
      /* the third received value indicates the servo angle  */
      val=10*val+600; 
      servo[pin].writeMicroseconds(val);                  /* write value */
      s=-1;  /* we are done with servo write so go to -1 next*/
      break; /* s=81 taken care of                           */         


      
      /* s=90 means Query Script Type: 
         (0 adio, 1 adioenc, 2 adiosrv, 3 motor)             */
      
      case 90:
      if (val==57) { 
        /* if string sent is 99  send script type via serial */
        Serial.println(2);
      }
      s=-1;  /* we are done with this so next state is -1    */
      break; /* s=90 taken care of                           */



      /* s=210 to 212 means ENCODER ATTACH ***************** */
      
      case 210:
      /* the second value indicates the encoder number:
         either 0, 1 or 2                                    */
      if (val>47 && val<51) {
        enc=val-48;        /* calculate encoder number       */
        s=211;  /* next we need the first attachment pin     */
      } 
      else {
        s=-1; /* if value is not an encoder then return to -1*/
      }
      break; /* s=210 taken care of                          */


      case 211:
      /* the third received value indicates the first pin     
         from abs('c')=99, pin 2, to abs('¦')=166, pin 69    */
      if (val>98 && val<167) {
        pin=val-97;                /* calculate pin          */
        Enc[enc].pinA=pin;         /* set pin A              */
        s=212;  /* next we need the second attachment pin    */
      } 
      else {
        s=-1; /* if value is not a servo then return to -1   */
      }
      break; /* s=211 taken care of                          */


      case 212:
      /* the fourth received value indicates the second pin     
         from abs('c')=99, pin 2, to abs('¦')=166, pin 69    */
      if (val>98 && val<167) {
        pin=val-97;                /* calculate pin          */
        Enc[enc].pinB=pin;         /* set pin B              */
        
        /* set encoder pins as inputs                        */
        pinMode(Enc[enc].pinA, INPUT); 
        pinMode(Enc[enc].pinB, INPUT); 
        
        /* turn on pullup resistors                          */
        digitalWrite(Enc[enc].pinA, HIGH); 
        digitalWrite(Enc[enc].pinB, HIGH); 
        
        /* attach interrupts                                 */
        switch(enc) {
          case 0:
            attachInterrupt(getIntNum(Enc[0].pinA), isrPinAEn0, CHANGE);
            attachInterrupt(getIntNum(Enc[0].pinB), isrPinBEn0, CHANGE);
            break;  
          case 1:
            attachInterrupt(getIntNum(Enc[1].pinA), isrPinAEn1, CHANGE);
            attachInterrupt(getIntNum(Enc[1].pinB), isrPinBEn1, CHANGE);
            break;  
          case 2:
            attachInterrupt(getIntNum(Enc[2].pinA), isrPinAEn2, CHANGE);
            attachInterrupt(getIntNum(Enc[2].pinB), isrPinBEn2, CHANGE);
            break;  
          }
        
      } 
      s=-1; /* we are done with encoder attach so -1         */
      break; /* s=212 taken care of                          */


      /* s=220 means ENCODER DETACH  *********************** */
      
      case 220:
      /* the second value indicates the encoder number:
         either 0, 1 or 2                                    */
      if (val>47 && val<51) {
        enc=val-48;        /* calculate encoder number       */
        /* detach interrupts */
        detachInterrupt(getIntNum(Enc[enc].pinA));
        detachInterrupt(getIntNum(Enc[enc].pinB));
      }
      s=-1;  /* we are done with encoder detach so -1        */
      break; /* s=220 taken care of                          */


      /* s=230 means GET ENCODER POSITION ****************** */
      
      case 230:
      /* the second value indicates the encoder number:
         either 0, 1 or 2                                    */
      if (val>47 && val<51) {
        enc=val-48;        /* calculate encoder number       */
        /* send the value back                               */
        Serial.println(Enc[enc].pos);
      }
      s=-1;  /* we are done with encoder detach so -1        */
      break; /* s=230 taken care of                          */


      /* s=240 means RESET ENCODER POSITION **************** */
      
      case 240:
      /* the second value indicates the encoder number:
         either 0, 1 or 2                                    */
      if (val>47 && val<51) {
        enc=val-48;        /* calculate encoder number       */
        /* reset position                                    */
        Enc[enc].pos=0;
      }
      s=-1;  /* we are done with encoder detach so -1        */
      break; /* s=240 taken care of                          */


      /* s=250 and 251 mean SET ENCODER DEBOUNCE DELAY ***** */
      
      case 250:
      /* the second value indicates the encoder number:
         either 0, 1 or 2                                    */
      if (val>47 && val<51) {
        enc=val-48;        /* calculate encoder number       */
        s=251;  /* next we need the first attachment pin     */
      } 
      else {
        s=-1; /* if value is not an encoder then return to -1*/
      }
      break; /* s=250 taken care of                          */


      case 251:
      /* the third received value indicates the debounce 
         delay value in units of approximately 0.1 ms each 
         from abs('a')=97, 0 units, to abs('¦')=166, 69 units*/
      if (val>96 && val<167) {
        Enc[enc].del=val-97;       /* set debounce delay     */
      }
      s=-1;  /* we are done with this so next state is -1    */
      break; /* s=251 taken care of                          */



      /* s=340 or 341 means ANALOG REFERENCE *************** */
      
      case 340:
      /* the second received value indicates the reference,
         which is encoded as is 0,1,2 for DEFAULT, INTERNAL  
         and EXTERNAL, respectively. Note that this function 
         is ignored for boards not featuring AVR or PIC32    */
         
#if defined(__AVR__) || defined(__PIC32MX__)

      switch (val) {
        
        case 48:
        analogReference(DEFAULT);
        break;        
        
        case 49:
        analogReference(INTERNAL);
        break;        
                
        case 50:
        analogReference(EXTERNAL);
        break;        
        
        default:                 /* unrecognized, no action  */
        break;
      } 

#endif

      s=-1;  /* we are done with this so next state is -1    */
      break; /* s=341 taken care of                          */



      /* s=400 roundtrip example function (returns the input)*/
      
      case 400:
      /* the second value (val) can really be anything here  */
      
      /* This is an auxiliary function that returns the ASCII 
         value of its first argument. It is provided as an 
         example for people that want to add their own code  */
         
      /* your own code goes here instead of the serial print */
      Serial.println(val);

      s=-1;  /* we are done with the aux function so -1      */
      break; /* s=400 taken care of                          */



      /* ******* UNRECOGNIZED STATE, go back to s=-1 ******* */
      
      default:
      /* we should never get here but if we do it means we 
         are in an unexpected state so whatever is the second 
         received value we get out of here and back to s=-1  */
      
      s=-1;  /* go back to the initial state, break unneeded */



    } /* end switch on state s                               */

  } /* end if serial available                               */
  
} /* end loop statement                                      */




/* auxiliary function to handle encoder attachment           */
int getIntNum(int pin) {
/* returns the interrupt number for a given interrupt pin 
   see http://arduino.cc/it/Reference/AttachInterrupt        */
switch(pin) {
  case 2:
    return 0;
  case 3:
    return 1;
  case 21:
    return 2;
  case 20:
    return 3;
  case 19:
    return 4;
  case 18:
    return 5;   
  default:
    return -1;
  }
}


/* auxiliary debouncing function                             */
void debounce(int del) {
  int k;
  for (k=0;k<del;k++) {
    /* can't use delay in the ISR so need to waste some time
       perfoming operations, this uses roughly 0.1ms on uno  */
    k = k +0.0 +0.0 -0.0 +3.0 -3.0;
  }
}


/* Interrupt Service Routine: change on pin A for Encoder 0  */
void isrPinAEn0(){

  /* read pin B right away                                   */
  int drB = digitalRead(Enc[0].pinB);
  
  /* possibly wait before reading pin A, then read it        */
  debounce(Enc[0].del);
  int drA = digitalRead(Enc[0].pinA);

  /* this updates the counter                                */
  if (drA == HIGH) {   /* low->high on A? */
      
    if (drB == LOW) {  /* check pin B */
  	Enc[0].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[0].pos--;  /* going counterclockwise: decrement  */
    }
    
  } else {                       /* must be high to low on A */
  
    if (drB == HIGH) { /* check pin B */
  	Enc[0].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[0].pos--;  /* going counterclockwise: decrement  */
    }
    
  } /* end counter update                                    */

} /* end ISR pin A Encoder 0                                 */



/* Interrupt Service Routine: change on pin B for Encoder 0  */
void isrPinBEn0(){ 

  /* read pin A right away                                   */
  int drA = digitalRead(Enc[0].pinA);
  
  /* possibly wait before reading pin B, then read it        */
  debounce(Enc[0].del);
  int drB = digitalRead(Enc[0].pinB);

  /* this updates the counter                                */
  if (drB == HIGH) {   /* low->high on B? */
  
    if (drA == HIGH) { /* check pin A */
  	Enc[0].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[0].pos--;  /* going counterclockwise: decrement  */
    }
  
  } else {                       /* must be high to low on B */
  
    if (drA == LOW) {  /* check pin A */
  	Enc[0].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[0].pos--;  /* going counterclockwise: decrement  */
    }
    
  } /* end counter update */

} /* end ISR pin B Encoder 0  */


/* Interrupt Service Routine: change on pin A for Encoder 1  */
void isrPinAEn1(){

  /* read pin B right away                                   */
  int drB = digitalRead(Enc[1].pinB);
  
  /* possibly wait before reading pin A, then read it        */
  debounce(Enc[1].del);
  int drA = digitalRead(Enc[1].pinA);

  /* this updates the counter                                */
  if (drA == HIGH) {   /* low->high on A? */
      
    if (drB == LOW) {  /* check pin B */
  	Enc[1].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[1].pos--;  /* going counterclockwise: decrement  */
    }
    
  } else { /* must be high to low on A                       */
  
    if (drB == HIGH) { /* check pin B */
  	Enc[1].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[1].pos--;  /* going counterclockwise: decrement  */
    }
    
  } /* end counter update                                    */

} /* end ISR pin A Encoder 1                                 */


/* Interrupt Service Routine: change on pin B for Encoder 1  */
void isrPinBEn1(){ 

  /* read pin A right away                                   */
  int drA = digitalRead(Enc[1].pinA);
  
  /* possibly wait before reading pin B, then read it        */
  debounce(Enc[1].del);
  int drB = digitalRead(Enc[1].pinB);

  /* this updates the counter                                */
  if (drB == HIGH) {   /* low->high on B? */
  
    if (drA == HIGH) { /* check pin A */
  	Enc[1].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[1].pos--;  /* going counterclockwise: decrement  */
    }
  
  } else { /* must be high to low on B                       */
  
    if (drA == LOW) {  /* check pin A */
  	Enc[1].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[1].pos--;  /* going counterclockwise: decrement  */
    }
    
  } /* end counter update                                    */

} /* end ISR pin B Encoder 1                                 */


/* Interrupt Service Routine: change on pin A for Encoder 2  */
void isrPinAEn2(){

  /* read pin B right away                                   */
  int drB = digitalRead(Enc[2].pinB);
  
  /* possibly wait before reading pin A, then read it        */
  debounce(Enc[2].del);
  int drA = digitalRead(Enc[2].pinA);

  /* this updates the counter                                */
  if (drA == HIGH) {   /* low->high on A? */
      
    if (drB == LOW) {  /* check pin B */
  	Enc[2].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[2].pos--;  /* going counterclockwise: decrement  */
    }
    
  } else { /* must be high to low on A                       */
  
    if (drB == HIGH) { /* check pin B */
  	Enc[2].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[2].pos--;  /* going counterclockwise: decrement  */
    }
    
  } /* end counter update                                    */

} /* end ISR pin A Encoder 2                                 */


/* Interrupt Service Routine: change on pin B for Encoder 2  */
void isrPinBEn2(){ 

  /* read pin A right away                                   */
  int drA = digitalRead(Enc[2].pinA);
  
  /* possibly wait before reading pin B, then read it        */
  debounce(Enc[2].del);
  int drB = digitalRead(Enc[2].pinB);

  /* this updates the counter                                */
  if (drB == HIGH) {   /* low->high on B? */
  
    if (drA == HIGH) { /* check pin A */
  	Enc[2].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[2].pos--;  /* going counterclockwise: decrement  */
    }
  
  } else { /* must be high to low on B                       */
  
    if (drA == LOW) {  /* check pin A */
  	Enc[2].pos++;  /* going clockwise: increment         */
    } else {
  	Enc[2].pos--;  /* going counterclockwise: decrement  */
    }
    
  } /* end counter update                                    */

} /* end ISR pin B Encoder 2                                 */
 
SİZCE NASIL OLMUŞ?
Beğendim
73%
İlginç
14%
Eh İşte
4%
Anlamadım
5%
Kötü
1%
Berbat
4%
YAZAR HAKKINDA
Sezgin Gül
Atatürk Üniversitesi Makine Mühendisliği bölümünde lisans eğitimi almaktayım.Bölümüme paralel olarak robotik sistemler üzerine projeler geliştirmekteyim. Disiplinli ve düzenli çalışmayı severim.Sürekli yeni şeyler öğrenmeye hevesli, kendi alanımdaki konularda uzman, kendi kendime öğrenebilen, aktif çalışmayı seven, dinamik bir kişiliğim vardır.Ayrıca takım çalışmasına yatkın, değişime açık, yaratıcı, yenilikçi, çalışkan ve kararlı biriyimdir.
80 YORUMLAR
1 2
  • merve
    1 Temmuz 2015 at 03:22

    slm hocam robot kol icicn sg 5010 uygunmu bıde hocam su matlab nasıl atacagımız konusunda resımlı gostere bılırmısınız bu projeye cok ıhtıyacım var ne olur sızden yardım beklıyorum meilde atabılırsınız cok tşkr ederim

    • 1 Temmuz 2015 at 04:26

      İsteğiniz servo motoru kullanabilirsiniz.Sadece yeterli miktarda enerji vermeniz gerekmekte aksi halde titremeler veya istenmeyen davranışlar gösterebilir.Matlab’a bağlanmayı resimli olarak kısa zamanda paylaşacağım.

      • merve
        1 Temmuz 2015 at 04:46

        cok tşkr ederım finaldraw . m ismı yazdıktan sonra bı işlem yapılıyomu

        • 1 Temmuz 2015 at 04:52

          Arduino takılı olduğu port numarasını finaldraw.m dosyasındaki a=arduino(‘COM3’); satırındaki com blümüne yazınız.Sonra kodu çalıştırın.

        • merve
          1 Temmuz 2015 at 04:58

          hocam mablab resim cızen proje ıcın tekrar rahatsız edıyorum ozur dılerım ben mablab 2011 verıyonuda kulanıyom acaba bu engel olurmu projenın detaylı resımlerını bana kısa bı surede yollasanız cok sevınırım mınnettar olurum ogrencılerımı bu projeyı ogretıcem cok sıteyı arastırdım ama bulamdım sız bıraz daha detaylı aanlatmısınız tek kalan sorun mablab dosyalırı nasıl atıcagım ve nasıl calıstıracagım sanırım sızden baska yardımcı olacak kımse yok yardımınızı beklıyorum tşkr

          • 1 Temmuz 2015 at 05:09

            Sorun olmaz.Matlab dosyalarını ve çizdirmek isteğiniz fotoğrafı aynı klasör içine atın.Matlab programını açın ve browse for folder butonuna tıklayın.Buradan matlab dosyalarının olduğu klasörü seçin ve onaylayın.Yazıdaki resimde görüldüğü gibi matlab dosyalarınızı göreceksiniz.Sonra finaldraw dosyasını açın.İlk satırdaki fotoğraf ismini attğınız fotoğrafın ismiyle değiştirin.ayrıca fotoğrafınızın uzantısı farklı ise onu da değiştirin.Arduino kartınızı pc ye takın.Koddaki port numarasını da arduino kartınızın bağlı olduğu port numarasıyla değiştirin.
            arduino.m matlab dosyasını açın Ve üstteki run butonuna tıklayın.Bu sayede matlab arduino’ya bağlanacak.Ardından finaldraw.m dosayasını açın ve üsttekirun butonuna basarak çalıştırın.

  • merve
    1 Temmuz 2015 at 05:20

    son soru hocam calıstır dıgınce su hatayı verıyo
    ??? Error using ==> imread at 374
    File “foto” does not exist.

    Error in ==> finaldraw at 1
    u=imread(‘foto’);

    ??? Undefined variable “vision” or class “vision.CascadeObjectDetector”.

    Error in ==> finaldraw at 5
    EyeDetect = vision.CascadeObjectDetector(‘EyePairBig’);

    • 1 Temmuz 2015 at 05:22

      çizdireceğiniz fotoğrafıni ismini foto yapmalısınız veya koddaki foto isminin yerine sizin fotoğrafınızın adını yazmalısınız.

  • merve
    1 Temmuz 2015 at 05:29

    Error in ==> finaldraw at 5
    Eye Detect = vision.CascadeObjectDetector(‘Eye Pair Big’);

  • merve
    1 Temmuz 2015 at 05:32

    sanırım olmuyo yapamıyom 🙁 gercı pc arduino tek baglı dıger parcalarını yapmadım sorun oda olabıırmı

  • merve
    1 Temmuz 2015 at 05:36

    ??? Undefined variable “vision” or class “vision.CascadeObjectDetector”.

    Error in ==> finaldraw at 5
    EyeDetect = vision.CascadeObjectDetector(‘EyePairBig’);ye Pair Big’);

  • merve
    1 Temmuz 2015 at 05:40

    yada atacagım fotonun boyutumu olmalı yada sadece yuz fotosumu olmalı

  • 1 Temmuz 2015 at 05:44

    arduino pc ye bağlı olsun yeterli. aynı hatayı mı alıyorsunuz yine?

  • merve
    1 Temmuz 2015 at 05:47

    ??? Undefined variable “vision” or class “vision.CascadeObjectDetector”.

    Error in ==> finaldraw at 5
    EyeDetect = vision.CascadeObjectDetector(‘EyePairBig’); evet 🙁

  • merve
    1 Temmuz 2015 at 05:50

    Note: a DEMO connection will be created
    Use a the com port, e.g. ‘COM5’ as input argument to connect to the real board
    Demo mode connection …….
    Motor Shield V2 (plus adioes.pde functions) sketch detected !
    Arduino successfully connected ! arduino.m calıstırınca bu cıkıyo COM 5 DIYO ACABA SURUN BU OLABILIRMI SIZCE

  • merve
    1 Temmuz 2015 at 05:59

    evet attım onlarda sorun yok sadece calısmayan finaldraw.m buda dedıgınız gıbı belı eskı versıyon olur onda sanırım yada fotoların buyukluk kucukluk le ılgılı olabılır yada her ıstedıgız fotoyu cızmıyo bellı fotoları cıze bılır ama bana gercekten cok yardımcı oldunuz ılgınız ıcın cok tşkr ederım sızı bu vakte kadar yordum ama yapamasam tekrar sızı rahatsız edıcem

    • 1 Temmuz 2015 at 06:04

      Rica ederim merve hanım.Dediğim gibi sürüm farkından olması gerekiyor.Ben 2013 versiyonda çizdirdim sorunsuz çalışıyor.Ayrıca her fotoğrafı çiziyor .yalnız fotoğraf boyutu 350×450 civarı olursa hatasız çizim yapabilirsiniz.Takıldığınız yerde sorabilirsiniz.

  • merve
    1 Temmuz 2015 at 06:08

    cok tşkr 2013 versıyonunu ındırıyom artık yarına bakıcam ınsallah olur bana cok ama cok yardımcı oldunuz tekrar tşkr ederım hayırlı ramazanlar eger vaktınız olursa tekrar gorusurz

  • merve
    2 Temmuz 2015 at 02:21

    matlab 2013 indırdımde crak ve serial yok bulamıyom

  • merve
    2 Temmuz 2015 at 03:39

    key kabul etmedı ındırdıgım 2013
    as installkey use 12345678901112131415 for standalone
    or 22345678901112131415 for network version bunlarda key sanırım

  • merve
    2 Temmuz 2015 at 03:58

    youtubeden baktım bıtane key denedım oldu şimdı yukluyom ilgınız ıcın tşkr sızı rahatsız edıyom ozur dılerım

  • merve
    2 Temmuz 2015 at 04:12

    tşkr edrım valla zaten sıze sorarım gecmısınızı okudum baya ıyısınız bu konularda sızden baskası yardımcı olacagını sanmıyom zaten

  • merve
    2 Temmuz 2015 at 04:54

    Error using vision.CascadeObjectDetector
    The specified superclass ‘matlab.system.System’ contains a parse error or cannot be found on MATLAB’s search
    path, possibly shadowed by another file with the same name.

    Error in finaldraw (line 5)
    EyeDetect = vision.CascadeObjectDetector(‘EyePairBig’); bu hatayı verdı sanırım vazgecıcem olmuyo 🙁

    • 2 Temmuz 2015 at 05:06

      bilgisayarınızı kapatıp açın matlabi arduinoya bağlayın fotoğraf adlarının ve uzantılarının aynı olduğundan emin olun ayrıca Fotoğraf boyutu 350×450 civarı olsun.

  • merve
    2 Temmuz 2015 at 05:15

    Attempting connection ………….
    Analog & Digital I/O + Encoders + Servos (adioes.pde) sketch detected !
    Arduino successfully connected ! boyle olunca calısıyo demı

  • merve
    2 Temmuz 2015 at 05:30

    ozaman basardım cok tşkrler sızın sayenızde sız olmasanız asla yapamazdım tşkr son ıkı soru sorucam resımde 20 cm demırler gostermıs onun yerıne farlı bısey kulana bılırmıyız ornek tahta plastık bıde kulanacagımız enerjının 5 v 2 a demıs farklı bı guc kulana bılırmıyız bıde cızımler guzel cıkıyomu bunlada ılgılı bırazcık acıklama yaparmısın

    • 2 Temmuz 2015 at 06:01

      Demir yerine mukavemeti yüksek esneme yapmayan malzeme kullanabilirsiniz.Biz pleksi malzeme kullandık sorun yaşamadık.Fakat uzunlukları aynı olsun aksi halde yanlış çizim yapar.Servo motorlar için 5v 2a verirseniz tam verimle çalışmasını sağlarsınız titremeleri ve istem dışı hareket etmesini önlersiniz.4.8 ile 6 volt arası enerji verirseniz de pek sorun yaşamassınız.Çizimlerin kaliteli çıkmasını istiyorsanız çizdireceğiniz fotoğrafın görüntü kalitesi ne kadar iyi olursa matlab de o derece iyi resmi işler ve net çizim yapılmasını sağlamış oluruz.ayrıca fotoğraf boyutunu maksimum 350×450 olmasına dikkat edin.

  • merve
    2 Temmuz 2015 at 06:20

    sıze cok cok tşkr ederım benı kırmadınız herdedıgıme cevap verdınız ılgılendınız sızın sayenız basardım tşkr

  • merve
    7 Temmuz 2015 at 02:38

    yapamadım sanırım kagıtın boyutunu bılmıyom bıde motorlara dengeyı saglıyamıyom 🙁

    • 7 Temmuz 2015 at 03:08

      kağıdın boyutu A3 civarı yeterli buyuklukte olsun.Mekanik denge sağlamanız için şekildede gösterdiği üzere kolun altına iki adet sarhoş tekerlek koyarsanız kod farkını dengelersiniz yanı yatay pazisyona getitirirsiniz .sabit duran baştaki servoyu tam sabitlemesiniz aksi halde torktan dolayı yerinden kayabilir.

  • merve
    7 Temmuz 2015 at 03:17

    calısıyoduda ama hatalı cok buyuk cızım yapıyodu buda ekran dısına tasıyodu ondan sureklı hata verıyodu

    • 7 Temmuz 2015 at 03:28

      çizdirdiğiniz resmin boyutu çok büyük olursa hata verir.çünkü robot kolun en uzak köşeye çizeceği yer belli yani 40 cm ye yakın bir çapta çizim yapacaktır.resminizin boyutları 340×440 ı geçmesin.

  • merve
    7 Temmuz 2015 at 03:31

    mekenık mandal ucuna kadar toplam 40 cm olmalı dımı 1 cm gecerse hatamı verırı

    • 7 Temmuz 2015 at 03:37

      evet 40 cm olmalı.büyük veya küçük olması yazılımsal olarak hata vermez fakat çizimler birbirleriyle çakışabilir bu da resmin yanlış çizileceği anlamına gelir.

  • merve
    7 Temmuz 2015 at 03:39

    anladım mekanı ıcın baska nasıl parca kulanamalıyız

    • 7 Temmuz 2015 at 03:45

      projedeki gibi metal legolar kullanırsanız hem kolay hemde sağlam olur. Başka alternatif olarak pleksi veya mika levhadan yapabilirsiniz.Önemli olan esneme yapmayan malzeme kullanın.Siz şuan hangi malzeme kullandınız ki mekanik sorun yaşıyorsunuz?

  • merve
    7 Temmuz 2015 at 03:51

    metal kulandım ama ınceydı sanırım 1 cm genıslık 20 cm uzunluk

  • merve
    7 Temmuz 2015 at 04:03

    valla ne dıyeyım yasadım egrılme oldu mekanıkte bundan dolayı saglan bı parca bulmalıyım bıde kulaacaımız mekanıgın kalınlıgı orne k projede mekanınk torkun altına vıdalanmıs bız usten vıdelarsak kalın parcada olrsa sorun olurmu bıde kulanılan kalem farklı bı kalemmı ozur dılerım gene sızı rahatsız ettım

    • 7 Temmuz 2015 at 04:24

      Öncelikle servo motorun torkuna göre malzemenin ağırlığına dikkat edin.Montaj da dikkat edeceğiniz nokta eklem yerleri arası mesafeler.Vidalamayı projedeki gibi yapmalısınız ki kod farkı az olsun.Bu kod farkını kapatmak içinde levhanın altına iki adet sürtünmesi az olan ve dengede durabilecek şekilde sarhoş tekerlekler veya ona benzer destekler yapıştırın. .Kaleminiz de keçeli veya mürekkepli olursa net çizeceği için iyi olur.kurşun veya tükenmez kalemde tam netlik alamayabilirsiniz.

  • merve
    7 Temmuz 2015 at 04:30

    bılgılerınız ıcın cok tşkr ederım yıne vaktınısız aldım tekrar denıyıcem yapmaya calısıcam ınsalah sonunda olucak yarına artık gorusmek uzere tşkr

  • merve
    9 Temmuz 2015 at 03:05

    genede olmadı bı turlu kagıdın uzerını dengelemıyo sureklı robot kagıdın uzerınden tasıyo

    • 9 Temmuz 2015 at 17:21

      Eklemleri çıkartın. Servoların açılarını 90 dereceye getirin ve o konumda iken eklemleri takın.sabit eklem kağıda paralel. orta eklem de iki kolun birbirine dik olacak şekilde takın. çalıştırdığınızda başlama noktası bu şekilde olacağından kağıt dışına çizim yapmayacaktır.

    • 9 Temmuz 2015 at 17:28

      ikinci bi yöntem de kol çalıştığında çizime başlamadan önce başlangıç konumuna geçer.Bu konuma geçtiğinde enerjiyi kesin ve açıları oynatmadan eklem yerlerini çıkartın birinci kol kağıda paralel ikinci kol ise birinci kola dik olacak şekilde takın.tekrar çalıştırdığınızda bu konumdan çizime başlayacak ve kağıdın dışına taşmayacaktır.

  • merve
    10 Temmuz 2015 at 06:06

    tşkr ederım bıde kalemı ayarlamak zor ya resım boyutu buyuk olursa cızımde buyukmı oluyo acaba

    • 10 Temmuz 2015 at 13:08

      kalem açısı 92 derecede kaldırıyor 85 derecede yazdırıyor. Servonuzu ters koyarsanız tam tersi olur.
      Resimde kısıtlama var tabikide.Maksimum çizeceği boyut kolun uzunluğunu geçemeyeceğinden hata verecektir.Zaten büyük bir resim atarsanız hata alabilirsiniz.

  • merve
    13 Temmuz 2015 at 03:51

    motorları resimdekı gıbı yerlestırdım painten bı yuvarlak resim yaptım deneme yeptım nasıl cızecek dıye cızdıde tam yuvarlak olarak cızmedı mekanık ornek 20 cm 21 ceme olursa sorun olurmu cok hatalı yaparmı bıde bu kalemı tam tuturamadım

    • 13 Temmuz 2015 at 15:40

      Kolun uzunluklarını değiştirirseniz doğru çizmez.Açısal hesaplamalarla algoritma geliştirildiği için sorun yaşarsanız.Projedeki boyutlarla birebir yapmalısınız.Kalemi tutturmak için epoksi yapıştırıcıyla mandala yapıştırsanız sorun çözülür diye düşünüyorum.

  • merve
    16 Temmuz 2015 at 00:05

    cok tşkr yardımlarınız icin

  • gokan21
    12 Ekim 2015 at 15:29

    Merhaba hocam projenizi gördüm ve çok beğendim. Benimde okulumda bu projeye çok benzer bir araştırma ödevim var. Proje de açı hesaplaması için sanırsam ters kinematik kullanılmış, bu attığınız draw.m matlab dosyasında açı hesaplaması ve bunların servoya nasıl aktarıldığı kodları hiç anlayamadım ve ödevimde bu konu hakkında. Bana yardımcı olursanız çok ama çok sevinirim. Teşekkürler.

  • onur rifat erkurt
    9 Aralık 2015 at 22:02

    servo motorlar için motor sürücü kartı kullanmamız gerekiyor mu? tam şematik göremedim resimlerde. biraz daha ayrıntı verirseniz sevinirim.

  • Emre AKTAŞ
    30 Aralık 2015 at 10:48

    Hocam Kolay gelsin merhabalar;
    Benimde aklımda bir proje var, vector olarak hazırlanmış harfin örg; D harfinde 2 köşe var W ‘da 3 köşe var bunların köşe uzunlarını nasıl hesaplayabilrim ?
    Bu konuda bir yol gösterebilir misiniz ?

  • merve
    16 Ocak 2016 at 03:00

    slm hocam

  • Ese
    10 Mart 2016 at 19:26

    Merhabalar hocam paylaşımınız için çok teşekkür ediyorum .
    Size bir sorum olacaktı matlab da finaldraw dosyasını çalıştırdığımda
    şöyle bir hata alıyorum

    Error in finaldraw (line 3)
    w=edge(i,’canny’,[.05,.20]);

    acaba sorun nedir matlab konusunda fazla bilgili değilim yardımcı olursanız sevinirim teşekkürler.

YORUM YAP