Programowanie robotów metodami Online Programming z ArduinoUNO

[StrongVoltage]

               Słowem wstępu,  wyobraźmy  sobie  że  jesteśmy  na  słonecznej,  piaszczystej  plaży  wzdłuż  której rosną wysokie, bogate w orzechy kokosowe palmy. Pod jedną z  nich stoi lokalny, doświadczony,  zbieracz  kokosów, u którego mamy  zamiar nauczyć się  tego ciężkiego rzemiosła.  Jako  zaledwie  początkujący adepci tej trudnej sztuki, nie mamy  jednak zielonego pojęcia jak się do tego zabrać.  Dlatego nasz  nowy mentor  musi nam wytłumaczyć co i jak powinniśmy zrobić.  Może on  nam wytłumaczyć  wszystko krok po kroku.  Opisać dokładne pozycje naszych kończyn, prędkość z jaką  będziemy się wspinać i sposób odbierania kokosu. Oczywiście opisanie nam tego na tyle dokładnie, byśmy mogli bezbłędnie przystąpić do pracy wymagałoby dużo czasu i energii. Zamiast tego, może pokazać nam osobiście jak to zrobić i dać nam przystąpić do pracy. W krótkim i bogatym w informacje czasie, będziemy wiedzieli jak przystąpić do pracy.

Ten wpis brał udział konkursie na najlepszy artykuł o elektronice lub programowaniu. Sprawdź wyniki oraz listę wszystkich prac »
Partnerem tej edycji konkursu (marzec 2020) był popularny producent obwodów drukowanych, firma PCBWay.

               Po tym  ciut przydługawym  wstępie,  którym  starałem  się  nakreślić  pewien  problem,  możemy  przystąpić do właściwego omówienia tematu. Istnieje wiele metod programowania robotów przemysłowych (manipulatorów).  Wykonują  one  precyzyjne prace,  wymagające  wielu  skomplikowanych  ruchów.  Jednak  poza nimi,  roboty  mogą też wykonywać mniej skomplikowane ruchy np. podczas  zmiany pozycji lub przełączenia między poszczególnymi pracami.  O ile do wykonania operacji precyzyjnych niezbędny jest szczegółowo opracowany program,  o tyle podczas ruchów mniej skomplikowanych czas programowania można ukrócić do metod Online Programming.

               Krótki film przedstawiający podział metod programowania

                 Metody te pozwalają operatorowi manualnie lub za pomocą odpowiedniego kontrolera ustawić poszczególne pozycje robota, które zostaną przez niego zapamiętane w czasie bieżącym oraz odtworzone w postaci pożądanego przez nas ruchu.

Programowanie robota spawalniczego przy pomocy metody teach-in

Programowanie robota Festo BionicCobot przy pomocy metody play-back

               Programowanie play-back opiera się na sczytywaniu przez oprogramowanie pozycji robota, zapisywanie ich oraz odtwarzanie poprzez bezpośrednie poruszanie jego konstrukcją. Aby było to możliwe,  każdy  stopień  swobody  robota  musi posiadać sensor umożliwiający określenie jego dokładnej pozycji.  Oprócz  tego  napęd  robota  musi działać w wyrachowany i delikatny sposób, aby konstrukcja była jednocześnie sztywna i można było nią poruszać ręcznie.

               Programowanie  teach-in  z  kolei  polega  na  ustawieniu  robota  w ustalonych pozycjach za pomocą odpowiedniego kontrolera, za pomocą którego te pozycje zostaną zapisane a następnie odtworzone. Odtwarzanie kolejno zapisanych pozycji daje w efekcie płynny, ciągły ruch maszyny.

               Wyżej wspomniane metody omówimy na realnym przykładzie.  Za pomocą  kontrolera będziemy  mogli stosować na prostym manipulatorze metodę teach-in. Robot napędzany jest serwami modelarskimi oraz wykonany w technice druku 3D. Serwa posiadają wbudowane potencjometry sczytujące pozycje kątowe wałów, jednak bez ingerencji w ich budowę ciężko będzie korzystać z tych potencjometrów  do  określania  pozycji  robota.  Dlatego  manualne ustawienie pozycji manipulatora metodą play-back wypada z puli naszych opcji. Poza tym istniałaby duża szansa na uszkodzenie stosowanych w robocie serw. Zamiast tego, posłużymy się kontrolerem, który będzie kinetycznym modelem naszego manipulatora i pozwoli także zahaczyć o ideę play-back.

Ramię manipulatora wydrukowane w 3D, poniżej link do źródła

https://www.thingiverse.com/thing:1015238

               Kontroler odpowiada kinematyce prezentowanego robota i ma umieszczone potencjometry w każdym jego punkcie swobody. Poruszając nim, możemy ustalić rzeczywistą pozycję naszego manipulatora.   Budując r  obota  o  mniej  skomplikowanej   budowie,  możemy  pozostać  przy  samych  potencjometrach  np. zamontowanych na płytce stykowej. Jednak w przypadku tego robota korzystanie z tego rozwiązania byłoby trudniejsze i mniej wygodne w użytku.

Model kinematyczny manipulatora

                   Znając już budowę kontrolera oraz manipulatora, należy je już tylko do siebie podłączyć. Oprócz tego do układu dodane zostaną przyciski nagrywania oraz  odtwarzania ruchu.  Elektronika opiera się o mikrokontroler atmega328p. Zasilanie układu odbywa się z sieci napięciem 230 V. W obudowie znajduje się układ prostujący, przetwornica step-down zasilająca  serwomechanizmy oraz płytka arduino ze wspomnianym wcześniej mikrokontrolerem. Dla wygody wszystkie piny arduino zostały wyprowadzone na zewnątrz obudowy. Cały schemat przedstawianej konstrukcji znajduje się poniżej:               

              

Schemat układu

Lista opisanych komponentów:

-S1 – włącznik główny,

-S2 – przycisk nagrywania,

-S3 – przycisk odtwarzania,

-D1 – mostek Graetza 400V ; 4A,

-D2 – zielona dioda LED,

-C1 – kondensator elektrolityczny 1000µF ; 50V,

-C2 – kondensator elektrolityczny 220µF ; 25V,

-C3 – kondensator elektrolityczny 22µF ; 25V,

-C4 – kondensator ceramiczny 100nF,

-C5 – kondensator ceramiczny 22pF,

-C6 – kondensator ceramiczny 22pF,

-C7 – kondensator ceramiczny 100nF,

-R1 – rezystor 150 Ω,

-R2, R3, R4 – rezystor 1 kΩ,

-POT 1, POT 2, POT 3, POT 4, - 10 kΩ,

-Stabilizator napięcia LM7805,

-Przetwornica step-down LM2596,

-X1 – kwarc 16 MHz,

Połączenie układu

                 Po podłączeniu całej elektroniki można przystąpić do omówienia kodu arduino. Program ten został już zaopatrzony w bogatą ilość komentarzy, które na pewno pomogą osobom dopiero rozpoczynającym swoją przygodę z arduino:

//biblioteka umożliwiająca nie tylko sterowanie serwami, ale także ich prędkością
//nie jest ona koniecznością, wystarczy standardowa biblioteka <servo.h> oraz pozbycie się zmiennej 'predkosc' z koduć
#include <VarSpeedServo.h>

//definiujemy serwa używane w robocie:
VarSpeedServo servo1;
VarSpeedServo servo2;
VarSpeedServo servo3;
VarSpeedServo servo4;

//definiujemy przyciski nagrywania i odtwarzania:
const int przycisk_A = 2;
const int przycisk_B = 3;

//definiujemy wartości dla wciśniętych przycisków nagrywania i odtwarzania:
int przycisk_A_ON = 0;
boolean przycisk_B_ON = false;

//definiujemy potencjometry:
const int potencjometr1 = A0;
const int potencjometr2 = A1;
const int potencjometr3 = A2;
const int potencjometr4 = A3;

//definiujemy zmienne służące do odczytu wartości napięć z potencjometrów:
int potencjometr_1_odczyt;
int potencjometr_2_odczyt;
int potencjometr_3_odczyt;
int potencjometr_4_odczyt;

//definiujemy zmienne służące do zapisu wartości kąta położenia poszczególnego serwa:
int potencjometr_1_zapis;
int potencjometr_2_zapis;
int potencjometr_3_zapis;
int potencjometr_4_zapis;

//definiujemy tablice zapisujące położenie serwa:
int Pozycja_serva1[]={1,1,1,1,1};
int Pozycja_serva2[]={1,1,1,1,1};
int Pozycja_serva3[]={1,1,1,1,1};
int Pozycja_serva4[]={1,1,1,1,1};

void setup() 
{
  //definiujemy piny do których podłączone są serwa:
  servo1.attach(6);
  servo2.attach(9);
  servo3.attach(10);
  servo4.attach(11);

  //definiujemy piny wejściowe przycisków nagrywania i odtwarzania:
  pinMode(przycisk_A, INPUT_PULLUP);
  pinMode(przycisk_B, INPUT_PULLUP);

  //inicjalizacja portu szeregowego do podglądu działania programu:
  Serial.begin(9600);
}

void loop() 
{
  //ustalanie prędkości serw w zakresie od 0 do 180:
  int predkosc = 90;
  //zapis formuły umieszczania odczytanej z potencjometrów wartości do tabeli:
  potencjometr_1_odczyt = analogRead(potencjometr1);
  potencjometr_1_zapis = map (potencjometr_1_odczyt, 0, 1023, 20, 175);
  potencjometr_2_odczyt = analogRead(potencjometr2);
  potencjometr_2_zapis = map (potencjometr_2_odczyt, 0, 1023, 5, 175);
  potencjometr_3_odczyt = analogRead(potencjometr3);
  potencjometr_3_zapis = map (potencjometr_3_odczyt, 0, 1023, 5, 175);
  potencjometr_4_odczyt = analogRead(potencjometr4);
  potencjometr_4_zapis = map (potencjometr_4_odczyt, 0, 1023, 20, 160);

  //serwa przyjmują pozycje zapisane w tabelach:
  servo1.write(potencjometr_1_zapis, predkosc);
  servo2.write(potencjometr_2_zapis, predkosc);
  servo3.write(potencjometr_3_zapis, predkosc);
  servo4.write(potencjometr_4_zapis, predkosc);

  //przy kolejnym wciśnięciu przycisku nagrywania tabela każdego serwa zostanie 
  //nadpisana, zapamiętując obecną pozycję serwa:
  if(digitalRead(przycisk_A) == HIGH)
  {
    przycisk_A_ON++;
    switch(przycisk_A_ON)
    {
      case 1:
        Pozycja_serva1[0] = potencjometr_1_zapis;
        Pozycja_serva2[0] = potencjometr_2_zapis;
        Pozycja_serva3[0] = potencjometr_3_zapis;
        Pozycja_serva4[0] = potencjometr_4_zapis;
        Serial.println("Pozycja pierwsza zapisana");
       break;
       case 2:
        Pozycja_serva1[1] = potencjometr_1_zapis;
        Pozycja_serva2[1] = potencjometr_2_zapis;
        Pozycja_serva3[1] = potencjometr_3_zapis;
        Pozycja_serva4[1] = potencjometr_4_zapis;
        Serial.println("Pozycja druga zapisana");
       break;
       case 3:
        Pozycja_serva1[2] = potencjometr_1_zapis;
        Pozycja_serva2[2] = potencjometr_2_zapis;
        Pozycja_serva3[2] = potencjometr_3_zapis;
        Pozycja_serva4[2] = potencjometr_4_zapis;
        Serial.println("Pozycja trzecia zapisana");
       break;
       case 4:
        Pozycja_serva1[3] = potencjometr_1_zapis;
        Pozycja_serva2[3] = potencjometr_2_zapis;
        Pozycja_serva3[3] = potencjometr_3_zapis;
        Pozycja_serva4[3] = potencjometr_4_zapis;
        Serial.println("Pozycja czwarta zapisana");
       break;
       case 5:
        Pozycja_serva1[4] = potencjometr_1_zapis;
        Pozycja_serva2[4] = potencjometr_2_zapis;
        Pozycja_serva3[4] = potencjometr_3_zapis;
        Pozycja_serva4[4] = potencjometr_4_zapis;
        Serial.println("Pozycja piąta zapisana");
       break;
    }
  }
  //po wciśnięciu przycisku odtwarzania serwa będą przyjmować zapisane w tabelach pozycje
  //z odczekaniem 1.5 sekund w każdej pozycji:
  if(digitalRead(przycisk_B) == HIGH)
  {
    przycisk_B_ON = true;
  }
  if(przycisk_B_ON)
  {
    for(int i=0; i<5; i++)
    {
      servo1.write(Pozycja_serva1[i],predkosc);
      servo2.write(Pozycja_serva2[i],predkosc);
      servo3.write(Pozycja_serva3[i],predkosc);
      servo4.write(Pozycja_serva4[i],predkosc);
      Serial.println("Odtwórz ruchy");
      delay(1500);
    }
  }
  //czas opóźnienia działania programu, od jego nastawy zależy płynnośc pracy robota:
  delay(200);
}

Program działa w sposób następujący:

• Po uruchomieniu programu, za pomocą modelu kinematycznego będzie można bezpośrednio kontrolować ruch manipulatora,
• Jeżeli wciśniemy przycisk S2 (nagrywania), obecnie ustawiona pozycja robota zostanie zapisana,
• Program umożliwia zapisanie pięciu różnych pozycji,
• Jeżeli wybierzemy przycisk S3 (odtwarzania), robot zacznie odtwarzać wybrane przez nas pozycje w nieskończonej pętli,
• Aby wytyczyć nową sekwencję ruchów należy zresetować układ.

Efekt działania powyższego kodu przedstawia się następująco:

Dzięki funkcji monitora szeregowego w arduino można obserwować pracę manipulatora bezpośrednio:

Przepraszam wszystkich czytelników za jakość nagrań wideo, niestety ograniczały mnie możliwości sprzętowe. Przedstawiony wyżej kod jest prosty a przykład nieskomplikowany, jednak doskonale pokazuje podstawy działania tej metody. Nie mniej jednak mam nadzieję, że artykuł okaże się dla wielu osób pomocny.

Oprócz tego zostawiam jeszcze bibliotekę <VarSpeedServo> 😉 

VarSpeedServo-master.zip

Powodzenia we wszelkich przyszłych projektach i przygodach z elektroniką!

[Treker (Damian Szymański)]

Artykuł został opublikowany, więc podbijam, aby wszyscy widzieli go jako nowy temat 🙂

[SOYER]

@StrongVoltage dzięki za ten artykuł. Nie miałem pojęcia, że roboty przemysłowe można programować w tak prosty i intuicyjny sposób. Czy przy tych metodach, algorytmy pozwalają na wskazanie które pozycje, ruchy są kluczowe, a które sam algorytm może zoptymalizować?