Pojazd (autonomiczny), refleks (LEDy + przyciski) oraz line follower

Ciągle dwa/trzy niezależne projekty. Wygląda na to, że będą jednak trzy, bo Pan Bartek „atakuje” temat line followera (świetnie!)

1) zespół od pojazdu po sukcesie sterowania pojazdem przez człowieka (bluetooth) poznawał temat czujki odległości HC-SR04. Zamontowali już nawet „trzymak” w pojeździe – bez użycia wkrętaki! zuchy! 😉 Tak, tak – to „oklepany” układ, ale każdy od czegoś zaczyna – prawda? Trzymam więc kciuki za poprawne oprogramowanie go w pojeździe i zrobienie autonomicznego robota (poruszającego się bez ingerencji człowieka, w tym przypadku: wykrywającego kolizje i zmieniającego kierunek ruchu).

2) „refleks” przeszedł w stan rozbudowany i teraz składa się z 3 losowo zapalanych LEDów, i łapaniu reakcji przez 3 przyciski. Układ:

oraz program (+dużo komentarzy):

//piny z podlaczonymi przyciskami
int btn[]={2,4,6};
//piny z podlaczonymi ledami
int led[]={3,5,7};

void setup() {
  Serial.begin(9600);
  for (int i=0; i<3; i++){
    pinMode(btn[i],INPUT_PULLUP);
    pinMode(led[i], OUTPUT);
  }
}

unsigned int i;
unsigned int cr,tstart,tstop;
byte bt1, bt2, bt3, LOS;

void loop() {
  //"dysko-mode" informujace o poczatku rozgrywki
  for(i=0;i<3;i++){
        digitalWrite(led[0], HIGH);
        delay(100);
        digitalWrite(led[1], HIGH);
        digitalWrite(led[0], LOW);
        delay(100);
        digitalWrite(led[2], HIGH);
        digitalWrite(led[1], LOW);
        delay(100);
        digitalWrite(led[2], LOW);
        delay(100);
    }//"dysko-mode"
      
   //(pseudo)losowe czekanie: od 1s do 5s
   delay(random(1000,5000));

   //wybor LEDa do zaswiecenia: 1,2 lub 3
   LOS=random(1,4);
   
   //wersja tylko do testow: wypisywanie na ekran losowania
   Serial.print("LOS=");
   Serial.println(LOS);

   //wlaczenie wylosowanego LEDa     
   //dzieki zapisaniu numerow pin-ow do tablicy jest to teraz bardzo proste!
   digitalWrite(led[LOS-1], HIGH);

   //rozpoczecie mierzenia czasu
   tstart = millis();
       
   //czekanie na rekacje uzytkownika - wcisniecie jednego z trzech pyrzycsikow
   //zapamietujemy w zmiennych, ktore przyciski sa wcisniete
   do{                
       bt1 = digitalRead(btn[0]);
       bt2 = digitalRead(btn[1]);
       bt3 = digitalRead(btn[2]);                
   }while(bt1+bt2+bt3==0); //petla wykonuje sie tak dlugo, az przynajmniej jeden z przyciskow zostanie wcisniety                          

   //zatrzymanie "stopera" skoro cos zostalo wcisniete
   tstop = millis();
   digitalWrite(led[LOS-1], LOW);     

   //okreslenie poprawnosci wcisniecia przycisku:
   //zakladamy, ze zle wcisniety przycisk (tak wygodniej)
   bool ok=false;   //czy wygralem? 

   //sprawdzenie, czy moze jednak zostal wcisniety odpowieni przycisk
   switch(LOS){
      case 1: if ((bt1==1)&&(bt2==0)&&(bt3==0)) ok=true;break;
      case 2: if ((bt2==1)&&(bt1==0)&&(bt3==0)) ok=true;break;
      case 3: if ((bt3==1)&&(bt1==0)&&(bt2==0)) ok=true;break;
    }//swicth

    //jesli wygrales, to stosowny komunikat
    if (ok){    
      cr = tstop-tstart; //cr = "czas rekacji"
      Serial.print("brako! gratulacje! ");    
      Serial.print("czas reakcji:");
      Serial.println(cr);
    }//ok==true
    else{    
      Serial.println("pudło! nie ten przycisk!");    
    }     
    delay(1000);
}//loop
         
        



Można jeszcze popracować nad tym kodem – można dodać kolejny (inny) „dysko-mode” informujące, że się poprawnie wybrało przycisk, albo zaświecić wszystkimi LED-ami, gdy użytkownik „spudłował”. W przyszłości dodamy do układu wyświetlacz LCD aby tam pojawił się stosowny komunikat, a nie na ekranie podłączonego komputera.

3) na bazie TSOP5000 (kiedyś już ją poznawaliśmy) powstanie czujnik do pojazdu typu line follower – praca się właśnie rozpoczyna. Działa już (podwójny) układ czujników, więc teraz rozpoczął się drugi etap: układ 3/4/5? czujek na własnoręcznej płytce prototypowej + pojazd na sterowniku L298.

Dlaczego własnoręcznie robiona czujka, a nie jedna z „kupnych”, jak te ze zdjęć poniżej?

Odpowiedź jest prosta: bo to fajniejsze i mamy więcej zabawy podczas pracy, a o to właśnie chodzi!

 

KG, 2018

Fale… z ledów… także wirtualnych…

Fala… z LED-ów…. prawdziwych! Oprócz fal pojawiła się TABLICA i pętla FOR. To sporo – kto nadążał – gratuluję!

Prezentacja Pana Macieja – proste, ale… całkiem efektowne! Gratuluję. Bez pętli zaprogramować coś takiego to koszmar.

Następnie zachęcałem do wirtualnego Arduino ze stronki tinkercad.com (jest to znany projekt cicuits.io, który przejęła firma Autodesk):

Stronka ta umożliwia zabawę w Arduino bez posiadania płytki Arduino – wystarczy się zarejestrować (za darmo!) i można działać.

Jak zacząć? Już po rejestracji wybieramy CIRCUITS:

a następnie zielony przycisk Create new circuits:

Kolejnym krokiem jest już dodawanie elementów po naciśnięciu +Components (prawy pasek, na górze)

gdzie zaczynamy od płytki stykówki, LED-a, rezystorka i bateryjki. Uruchamiamy symulację przyciskiem Start Simulation (potem ją zatrzymujemy Stop). Gdy już wszystko rozumiemy (tyle-o-ile) to czas na dodanie płytki Arduino i… tu się zaczyna zabawa!

Kto zrobi pracę domową z „odbijającą się” falą? Ze zmienną czas? Na następnych zajęciach wgramy programiki na prawdziwe płytki i zobaczymy kolorowe efekty! Proszę śmiało działać!

 

Pierwsze spotkanie 2017 r.

No i rozpoczęliśmy nowy rok akademicki 2017/2018 a tym samym i Fi-BOTa. Na pierwszych zajęciach pojawiło się 9 śmiałków – zobaczymy, ilu będzie kontynuować…

Co robiliśmy? Dla większości była to pierwsza przygoda z Arduino więc było sporo gadania, ale finalnie udało nam się błyskać jednym LED-em podłączonym na płytce stykowej. To dużo jak na godzinkę z hakiem i moją skłonność do gadania 😉 Ale pokazałem też motywację – ta sama płytka Arduino podłączona do żarówki 230V – i działa!

Spotkania w roku 2017/18 będą odbywać się zawsze we wtorki o godz. 16:00. Zapraszam!

Followliner (FL) – starcie 1

  1. Prosty FL – zbudowany na 2 czujnikach TCRT5000 ustawionych blisko siebie tak, by oba leżały nad czarną linią. Położenie czujek – z przodu, przy napędzie (wiem wiem…).
  2. Instalacja modułu w pojeździe.
  3. Pierwszy program – jedź prosto, gdy oba czujniki „widzą” linię.
  4. Modyfikacja – skręcaj (zatrzymując jedno koło) gdy jedna czujka „gubi” linię.
  5. Modyfikacja – silniki STOP, gdy obie czujki zgubiły linię.

Do zrobienia:

  1. (chwilowo) zostaniemy przy 2 czujkach, za to dodamy regulację szybkości kół w zależności od sygnału na czujce (aby nie było szarpania, a ruch był płynny).
  2. gdy pojazd wyjechał poza linię, to ma się cofnąć (może nawet kilka razy, a jeśli po tych kilku razach dalej nie widać linii – to dopiero wówczas STOP).
  3. zmodyfikujemy tor testowy – łagodniejsze łuki (łatwiejsze, ale z czasem zmienimy).

Liczymy obroty (TCRT5000) – sukces!

Liczymy obroty silniczka D65:

Znalezione obrazy dla zapytania d65 zestaw napedowytutaj nasz program:

 

bool stan, poprz;
unsigned long int t1;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  stan=false;
}

int odczyt;
int licz=0;
void loop() {
  poprz=stan;
  odczyt=analogRead(A0);
  if (odczyt<50)
    stan=true;
  else
    stan=false;
//  Serial.print(odczyt);
//  Serial.print("   ");
//  Serial.print(stan?"jasne":"ciemne");
//  Serial.print("   ");
  if (stan!=poprz){
    licz++;
    Serial.print(" KLIK ");
    Serial.print(licz);
    Serial.print(" ");
    if (licz%2==0){
      Serial.print(1000./(millis() - t1)*60);
      Serial.println(" rpm");
      t1= millis();
    }
  }
//  else
//    Serial.println();
}

I działa bardzo fajnie, nawet z tylko jednym znacznikiem! Wyniki są bardzo powtarzalne (przy zasilaniu około 7V – jeden obrót w 230-240ms, czyli 4 obroty w 1 sekundę, a to daje 4*60=240 obrotów na minutę – rpm).

Rozbudowa?

  1. więcej znaczników (już 2 polepszają sprawę, 4 to zdecydowanie OK).
  2. inny algorytm – zliczanie liczny obrotów i aktualizowanie wartości rpm co określony czas, np. 2 sek

Liczymy obroty (TCRT5000)

Liczymy obroty silniczka D65:

Znalezione obrazy dla zapytania d65 zestaw napedowy

który przy zasilaniu 6V powinien mieć 100 rpm (=obrotów na minutę). My wykorzystujemy poznaną czujkę odbiciową TCRT5000:

 

Znalezione obrazy dla zapytania tcrt5000

Pierwsze zgrubne wyniki dały 1 pełen obrót w czasie 250ms, czyli 240 rpm (trochę dużo, ale to dlatego, że zailalem silniczek 8V – „nielegalnie”). Zrzut ekranu:

oraz program (wyjaśnienia i dyskusja później, jak też i omówienie dokładności pomiaru):

int pomiar[3],i=0,maksior;
unsigned long t1,delta;

void setup() {
  Serial.begin(9600);
  t1=millis();    
}
void loop() {
//  Serial.print(millis());
//  Serial.print("   ");
  pomiar[0]=pomiar[1];
  pomiar[1]=pomiar[2];
  pomiar[2]=analogRead(A0);
  //Serial.println(pomiar[2]);  
  if ((pomiar[1]<950)&&(pomiar[1]>300)&&(pomiar[1]>pomiar[0])&&(pomiar[1]>pomiar[2])){
    delta=millis()-t1;
    if(delta>50){
      Serial.print("1 obrot w ");
      Serial.print(delta);
      t1=millis();    
      Serial.print("ms, czyli rpm=");  
      Serial.println(60*1000.0/delta); 
    }
  }  
  //delay(100);
}

 

 

Arduino: Przerwania + TCRT5000 do wykrywania szybkości obrotowej koła (04-05-2016)

Warto poczytać: https://www.arduino.cc/en/Reference/AttachInterrupt

oraz zapamiętać:

Płytka Piny cyfrowe pod które możemy podpiąć przerwania
Uno, Nano, Mini, other 328-based 2, 3
Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21
Micro, Leonardo, other 32u4-based 0, 1, 2, 3, 7
Zero wszystkie, za wyjątkiem 4
MKR1000 Rev.1 0 0, 1, 4, 5, 6, 7, 8, 9, A1, A2
Due wszystkie

oraz ,,zdarzenia”, podczas których uaktywni się funkcja przypisana pod dane przerwanie: LOW, CHANGE, RISING, FALLING (HIGH – tylko płytka Due). Krótko: funkcja „podpięta” do przerwania wywoła się wówczas, gdy na tym pinie (tym = zdefiniowanym podczas attachInterrupt) zajdzie konkretne „zdarzenie”, np. LOW. Oczywiście taka funkcja ma być szybka: ustalenie flagi, sterowanie napięciem na pinach – digitalWrite – ale nie delay(ileś-tam).

Przykład: Arduino + przycisk do błyskania diodą #13. Hardware: przycisk (mikroswicz podłączamy do GND a drugą nóżką do pinu #2 w Arduino).

#define PIN 2
bool stan=false;

void setup() {
pinMode(13, OUTPUT);
digitalWrite(13, 0);

pinMode(PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(PIN), blysk, LOW);
}

void loop() {
delay(10000);
}

void blysk(){
stan=!stan;
digitalWrite(13, stan); 
}

Gdy nic nie wiemy o przerwaniach, to przyglądając się funkcji loop() można by powiedzieć, że program NIC NIE ROBI! Tylko czeka 10s, a potem znowu czeka 10s, i tak w kółko… Więc skąd się bierze błyskanie diody #13 w momencie klikania przycisku? Otóż wywołanie delay() zatrzymuje działanie programu, ale przerwania ciągle działają. Skoro więc „podpięliśmy” naszą funkcję (o nazwie blysk()) do przerwania, to właśnie ona się wywoła (gdy stan pinu #2 zmieni się na LOW – to wszystko zostało powiedziane w funkcji setup()). Właśnie taki mechanizm wykorzystałem do wykrycia kolizji przez zderzak naszego pojazdu – pisałem o tym w poprzednim poście. UWAGA: powyższy program działa dość dynamicznie, „nerwowo” reagując na wciśnięcie przycisku – oczywiście jest to zjawisko drgania styków (ang. bouncing), o czym mówiliśmy na naszych poprzednich spotkaniach (tutaj, dla przejrzystości kodu nic z tym nie robię, brak jest debouncing-u).

Dodatkowo: zliczanie obrotów koła.

mDSC_1100

podłączyliśmy czujnik optyczny odbiciowy TCRT5000 do obudowy silniczka, a następnie wewnątrz koła umieściliśmy białą kartkę z czarną krechą. Czytamy wartości rejestrowane przez czujnik ale nie na Serial monitorze, ale GRAFICZNIE, za pomocą Processinga.

silniczek

Widzimy wyraźnie moment, gdy czujka mija czarną kreskę. Widać też, że piki zdecydowanie różnią się od „tła”, choć często mają różną wartość w maksimum. Łatwo wykombinować prosty algorytm (czy skuteczny? niedługo się o tym przekonamy) liczący szybkość obrotową koła:

  1.  zapisujemy t1, czyli czas pojawienia się maksimum (funkcja millis())
  2. czekamy na kolejne maksimum, gdy je złapiemy to
  3. zapisujemy t2, czyli czas pojawienia się kolejnego maksimum- wówczas różnica czasów t2 i t1 daje właśnie czas jednego, pełnego obrotu.

Pewnie „diabeł tkwi w szczegółach” ale powinno działać. Jak powiedziałem na zajęciach – więcej kresek (ale z umiarem! powiedzmy 4 na początek) powinny zwiększyć rozdzielczość zliczania liczby obrotów koła.

mDSC_1099

Będziemy to programować na kolejnych zajęciach…