Freestyle SAAR Romek - czyli (nie)mała modyfikacja robota z kursu Forbota

Danyeru · Sierpień 24, 2023

Cześć.
Przedstawiam wam Small Autonomous Amateur Rover "Romek" - czyli owoc mojej, z założenia kosmetycznej, metamorfozy robota, którego można poznać w jednym z forbotowych kursów. (A ponieważ robiłem tylko w wolnych chwilach, których wielu nie mam, to niczym ciąża - zacząłem z końcem listopada, mamy narodziny z końcem sierpnia).

Krótki zarys historyczny: Kilka lat temu miałem fazę, zakupiłem w Botlandzie kilka zestawów do kursów oraz tu i ówdzie trochę rzeczy do szuflady "przydasiów". Życie jednak weryfikuje i przez kilka lat zbierało kurz, aż w zeszłym roku przeszedłem w końcu kurs budowy robotów i kurs Arduino poziom I. Jednak chciałem przede wszystkim sterować robotem przez BT, do tego chciałem pozbyć się w jakiś sposób wężykowania. Odnalazłem info, że komunikacja z BT to w zasadzie komunikacja przez port szeregowy - zapiąłem HC-05, zainstalowałem aplikację Bluetooth RC Car i napisałem switch case pod dane wysyłane z tej apki.

Pierwsza rozbudowa "forbociaka" - moduł HC-05 i konwerter poziomów logicznych.

Robot jeździł sterowany przez BT i tyle. Podjąłem decyzję, że dokonam modyfikacji zarówno w kodzie, jak i wyglądzie - z tym ostatnim poszedł też warunek, tylko rzeczy z szuflady, żadnych nowych inwestycji - własny czelendż ruszył.

Posiadałem podwozie typu T100, które miało silniki z enkoderami - pomyślałem, że super, bo te silniczki z kursu to mogłyby mieć problem z ruszeniem cięższej konstrukcji, ponadto różny typ osi sprawił, że nawet nie próbowałem z nimi rzeźbić. Początkowa radość minęła wraz z przeczytaniem specyfikacji - maksymalny prąd pracy dołączonych silników to 4,5A, zdecydowanie za dużo na shield od Forbota. Przekopywałem szufladę dalej, znalazłem w niej silniczki N20, ale to maluszki, no i oś za mała. Znalazłem także silniki DFRobot o odpowiedniej osi i punktach montażowych. Przeczytałem notę - 7,5V, prąd pracy 50mA, maks. prąd 600 mA, przekładnia 99:1 - zostały wybrane.

Nie chciałem mieć elektroniki na zewnątrz, więc potrzeba było też obudowy. Na wstępie wybrałem Kradex Z125 na body i Kradex Z130 na czujnik odległości.

Jednak wraz z rozbudową, wybrana obudowa okazała się za ciasna - ledwo się zamykała, a nie założyłem jeszcze wszystkiego, co chciałem. Dodatkowo chciałem odzyskać pewne piny Arduino, które zajmował shield, a których nie potrzebowałem (przycisk i odbiornik IR).

Podjąłem decyzję o zmianie obudowy - miałem jeszcze Kradex Z112, która była szersza i nieco wyższa. Poprzednia obudowa wchodziła pomiędzy gąsienice, przy tej musiałem zastosować dystanse, żeby zamocować budę do podwozia i nie kolidować z gąsienicami.

Dodałem płaski koszyk na 6 baterii AA, krańcówki dla jazdy autonomicznej, połączone po dwie równolegle - żeby pokryć jak najwięcej czoła i jednocześnie nie odchylać blaszek pod dużym kątem i nie dodawać wąsów z trytytek - i wyłącznik kołyskowy, żeby załączać zasilanie z zewnątrz. Kanapkę Arduino+shield rozdzieliłem i połączyłem je przewodami, odzyskując wspomniane wcześniej piny cyfrowe 2 i 3 oraz uzyskując dostęp do pinu 3,3 V. Obudowę przed dalszymi pracami pomalowałem.

Żeby robot nie był tylko sterowanym autkiem, dodałem oczywiście czujnik odległości HC04-SR, czujnik temperatury i wilgotności DHT22 oraz dzielnik napięcia - zbudowany z rezystora 510k i dwóch 68k - dla pomiaru napięcia baterii.

Profesjonalny dzielnik amatorski.

Na koniec dodałem LED-y w oprawkach. 4 białe jako światła czołowe, każdy z rezystorem 1k. 2 zielone i 2 czerwone jako światła pozycyjne/nawigacyjne - również z rezystorami 1k. 2 żółte drogowe (już nie żółte, jeszcze nie pomarańczowe) jako światła ostrzegawcze, oczywiście z rezystorami 1k. 1 niebieski jako światło sygnalizujące jazdę autonomiczną, z rezystorem 330 Ohm. Niebieski LED jest zasilany i załączany bezpośrednio z Arduino. Pozostałe LED-y zasilane są z baterii i załączane przez tranzystory NPN BC548.

Ostatecznie wyszło trochę makaronu z przewodów, ale nie jest ciasno, obudowa zamyka się dobrze, a ja mam w razie W spis przewodów, a te z górnej części, które są wpięte w Arduino UNO są także opisane na wtykach. :)

Ponieważ żółte ledy miałem tylko typu clear i ich światło było widoczne tylko na wprost soczewki, dodałem dyfuzory zrobione ze... słomki.

Romek po montażu waży ok. 1290 g i prezentuje się tak:

Oprogramowanie:

Założyłem, że chcę się pozbyć delay(), żeby nie kolidować z DHT oraz żeby robot reagował natychmiast na polecenia. Czasami musiałem się naklikać zanim robot zareagował.

Czujnik odległości był jedną z prostszych rzeczy.
Zastosowałem bibliotekę New Ping, dla której utworzyłem obiekt:

NewPing sonar(trigPin, echoPin, MAX_DISTANCE);

Sama funkcja wygląda tak:

int sonarDystans() {
  int dystans = sonar.ping_cm();  // Wykonanie pomiaru i zapisanie wyniku w zmiennej distance w centymetrach
  return dystans;
}

A jej wykorzystanie na przykład tak:

if (sonarDystans() <= doPrzeszkody) { //Jeżeli w zadanej odległości jest przeszkoda
    obecnyStan = ZATRZYMAJ; //Przejdź do zatrzymania
    czasStanu = millis(); //Ustaw czas dla timera
    serwo.attach(SERWO_PIN); //Podłącz serwo
    }

Najwięcej problemów miałem z przepisaniem logiki jazdy autonomicznej. Poziom mojej wiedzy to kurs robota, kurs Arduino I i na coś tam liźnięte o DHT i millisach.
Tutaj nawet zatrudniłem forumowiczów do pomocy:

Ostatecznie oryginalną logikę wymieniłem na maszynę stanów, gdzie w danym stanie wywołuję funkcję, a dopiero w funkcji mam opisane zachowanie robota.

  switch (obecnyStan) {
    case PROSTO:
      prosto();
    break;

    case ZATRZYMAJ:
      zatrzymaj();
    break;

void zatrzymaj() {
  zatrzymajSilniki();
    if (millis() - czasStanu >= 500UL) { //Odczekaj zadany czas
      obecnyStan = PATRZ_PRAWO; //Przejdź do wykrywania przeszkody po prawej
      czasStanu = millis();
    }
}

W przypadku krańcówek musiałem dodać flagę dla kolizji, gdyż bez tego po wjechaniu w przeszkodę robot się zatrzymywał. Zapewne zanim zdążył przejść dalej program ponownie docierał do miejsca, gdzie natrafiał co zrobić po załączeniu krańcówki. Dodanie flagi sprawiło, że problem zniknął.

boolean kolizjaPrawo = false;

if (digitalRead(prawySensor) == LOW && kolizjaPrawo==0) { //Jeżeli przeszkoda po prawej
    kolizjaPrawo = 1;
    obecnyStan = COFAJ_PRAWY;
    czasStanu = millis(); 
  }

void cofajPrawy() {
  lewySilnik(-70);
  prawySilnik(-70);
    if (millis() - czasStanu >= 800UL) {
      obecnyStan = ZATRZYMAJ2; //Przejdź do wykrywania przeszkody po prawej
      czasStanu = millis();
      kolizjaPrawo = 0;
    }
}

Samo wejście w jazdę autonomiczną również realizowane jest zmianą flagi. W switch case dle odczytu z seriala/BT poczyniłem toggleswitch.

case 'A':
          jazdaAutonomiczna = !jazdaAutonomiczna;
          if (!jazdaAutonomiczna) {
            zatrzymajSilniki();
            ekspander.digitalWrite(LEDjazda, 0);
            serwo.detach();
          }
        break;

Nie ukrywam, że obsługę DHT podejrzałem w drugiej części kursu do Arduino, zanim tam dotrę, ale jak już wiemy, unikam delay(). Na podstawie obsługi czujnika z kursu i tego co wiem o millisach, napisałem funkcję po swojemu. Dodałem też korektę odczytów, gdyż względem czujnika referencyjnego temperatura była zawyżana o wilgotność zaniżana. Najpierw próbowałem korekty procentowej, ale ostatecznie wprowadziłem sztywną korektę. Względem czujnika referencyjnego odczyty nie odbiegają o więcej niż 0,5 stopnia i 0,5%.

W tym miejscu dodałem także odczyt z ADC, gdzie doprowadziłem wyjście z dzielnika napięcia dla baterii. Dla napięcia baterii 9,66 V napięcie doprowadzone z dzielnika wynosiło ok. 0,95 V. Po wstępnym obliczeniu mnożnika, ostateczną wartość dobrałem empirycznie. Rozbieżność nie przekracza 0,1 V, średnio jest to 0,06 V.
W funkcji tej następuje także wysyłanie danych na serial.

void humitemp () { //Funkcja czujnika DHT22 i pomiar napięcia
  float wilgotnosc = dht.getHumidity(); //Pobierz info o wilgotności do zmiennej
  float temperatura = dht.getTemperature(); //Pobierz info o temperaturze do zmiennej
  float wilgKorekta = wilgotnosc + 1.11; //Korekta dla odczytu wilgotności
  float tempKorekta = temperatura - 2.35; //Korekta odczytu temperatury
  int adc_val = analogRead(bateria); //Odczytaj wartość ADC
  float Ubat = adc_val * 0.0485340314; //Wylicz wartość napięcia
  czasDHT = millis(); //Pobierz aktualny czas Arduino
  roznicaDHT = czasDHT - odmierzDHT;

  if (roznicaDHT >= 2000UL) { //Jeżeli różnica wyniesie 2000 ms lub więcej
    odmierzDHT = czasDHT; //Zapisz aktualny czas arduino do zmiennej
    if (dht.getStatusString() == "OK") { //Jeżeli czujnik zwróci wartość ok, wykonaj poniższe
      Serial.print(tempKorekta);
      Serial.print(" °C");
      Serial.print("|");
      Serial.print(wilgKorekta);
      Serial.print(" %");
      Serial.print("|");
      Serial.print(Ubat);
      Serial.println(" V");
    }
  }
}

Wspomniałem wcześniej, że odzyskałem niektóre piny z Arduino. Zależało mi zwłaszcza na pinie PWM dla świateł pozycyjnych.
W prototypie używałem pinu ekspandera w trybie włącz-wyłącz, a pulsowanie osiągałem przez zastosowany kondensator, jednak nie dawało to pełnej kontroli.
Uwolniony pin PWM wykorzystałem właśnie do świateł pozycyjnych.

Zmienna kierunek ma wartość 1 lub -1, zatem wartość PWM jest zwiększana lub zmniejszana. Kiedy wartość PWM osiąga 0 lub 255 wartość zmiennej kierunek zostaje przemnożona przez -1 powodując zmianę jej wartości na przeciwną.

void swiatlaPuls() {
  aktualnyCzasPWM = millis();
  // Obsługa narastania i opadania PWM
  if (aktualnyCzasPWM - poprzedniCzasPWM >= interwalZmianyPWM) {
    poprzedniCzasPWM = aktualnyCzasPWM;

    wartoscPWM += kierunek; //Zmniana wartości PWM zależna od wartości kiereunku

    if (wartoscPWM >= 255 || wartoscPWM <= 0) {
      if (aktualnyCzasPWM - poprzedniCzasAnimacji >= interwalZmianyKierunku) {
        poprzedniCzasAnimacji = aktualnyCzasPWM;
        kierunek *= -1; // Zmiana kierunku narastania/opadania
      }
    }

    analogWrite(pulsLED, wartoscPWM);
  }
}

Dla świateł ostrzegawczych chciałem osiągnąć efekt szybkich mignięć wplecionych we włączanie i wyłączanie (włącz, zapulsuj, wyłącz, powtórz).
Pożądane zachowanie uzyskałem stosując switch case i zmienną dla licznika i zmieniając zachowanie świateł w zależności od jej wartości.

void swiatlaStrobo() {
  czasLEDstrobo = millis();
  switch(licznikStrobo) {
    case 0:
      digitalWrite(stroboLED, 1);
      if (czasLEDstrobo - czasStrobo >= 700UL) {
        digitalWrite(stroboLED, 0);
        czasStrobo = czasLEDstrobo;
        licznikStrobo ++;
      }
    break;

    case 13:
      digitalWrite(stroboLED, 0);
      if (czasLEDstrobo - czasStrobo >= 500UL) {
        digitalWrite(stroboLED, 0);
        licznikStrobo ++;
      }
    break;

    default:
      if (czasLEDstrobo - czasStrobo >= 50UL) {
        czasStrobo = czasLEDstrobo;
        stanStrobo = !stanStrobo;
        digitalWrite(stroboLED, stanStrobo);
        licznikStrobo ++;
      }
    break;
  }
  if (licznikStrobo > 13) {
    licznikStrobo = 0;
  }
}

Na koniec moja świeżynka. Poznałem operator trójargumentowy, zauważyłem, że dla mnie - tego amatora przed monitorem - działa podobnie do if else, zatem przepisałem logikę odpowiedzialną za silniki. Dotychczas używałem oryginalnej z kursu, po poznaniu tego operatora powstało coś takiego:

void lewySilnik (int VL) {
    if (VL == 0) return; //Jeżeli wartość VL jest równa zero to nie wykonuj funkcji
    int kierunekLewySilnik = (VL > 0) ? 0 : 1; //Jeżeli wartość VL jest większa od 0 to ustaw wartość 0 (jazda do przodu), jeżeli mniej to ustaw 1 (do tyłu)
    int vlMap = map(abs(VL), 0, 100, 0, PWM_MAX); //Przemapuj zakres PWM do zakresu 0-100, dla ujemnego VL zwróć wartość absolutną
    digitalWrite(L_DIR, kierunekLewySilnik); //Jazda do przodu, albo do tyłu :)
    analogWrite(L_PWM, vlMap); //Ustaw zadaną prędkość
}

Komunikacja - software:

Robot jest częściowo zgodny z aplikacją o której wspomniałem na początku (sterowanie, załączanie świateł co drugi kllik), ale gotowa apka nie do końca spełnia moje oczekiwania. Można też sterować przez aplikację typu BT serial monitor, ale to też nie do końca to - choć tutaj już odbieram dane.

Postanowiłem wyrzeźbić - to dobre słowo - aplikację w APP Inventorze. O ile w sekcji bloczkowej jakoś to poszło, to graficznie naprawdę była to rzeźba. Predefiniowane rozdzielczości są przedpotopowe, a i responsive nie do końca daje to, czego człowiek oczekuje.
Ale, potrzebowałem jednej apki, więc postanowiłem się przemęczyć, zamiast podejmować naukę tworzenia od podstaw w jakimś ludzkim środowisku.

W pierwszej wersji odbierałem temperaturę i wilgotność, napis "connect" był tylko etykietą. W drugiej odbieram jeszcze wartość napięcia.

Przyciski kierunkowe to przód, tyłu, obroty w miejscu w prawo, w lewo. Dodatkowo w narożnikach przyciski przywołują jazdę po łuku w daną stronę (prawy przód, lewy tył itp).
Przycisk H wyzwala impuls buzzerem.
Przycisk Światła uruchamia światła. Zmienna w robocie sprawia, że po kolei uruchamiane są: światła pozycyjne i ostrzegawcze, z drugim wywołaniem dochodzą światła frontowe, z trzecim wywołaniem gaszone są pozycyjne i ostrzegawcze, pozostają frontowe. Czwarte wywołanie resetuje zmienną i gasi wszystkie światła.
Przycisk Auto włącza lub wyłącza tryb jazdy autonomicznej.

Podsumowanie

Zdaję sobie sprawę, że kod nie jest idealny, zwłaszcza, że wiele rzeczy znałem po łebkach, niektórych uczyłem się w trakcie. Ale jestem zadowolony - coś, co miało być tylko dodaniem sterowania BT zmieniło się w duży jak dla mnie projekt, który robiony po godzinach ostatecznie działa.

Co dalej? Wyciągnę zasilanie jakoś zasilanie na zewnątrz. Zastosowana obudowa sprawia, że aby ją odkręcić, muszę ściągać gąsienice w celu uzyskania dostępu do śrub. To ze zwykłej wymiany baterii, czy przyszłych zmian w oprogramowaniu, zamienia rutynę w procedurę.

W drugiej części kursu Arduino widziałem czujnik ruchu, więc pewnie też go jakoś zatrudnię - zamysł taki, że w trybie auto będzie sobie oczekiwał i uruchamiał jazdę po wykryciu ruchu. A ponieważ szuflada zawiera jeszcze jednego HC-05, jakiegoś klona Nano i wyświetlacz OLED, mam w planie zrobić sprzętowy kontroler dla tego robota.

Co to za antenka? To tylko ozdoba - zabieram Romka ze sobą na ERC w tym roku - będzie maskotką.

Jaki koszt konwersji? Dla mnie żaden, jeżeli uznajemy, że co w szufladzie to 0 zł. Jeżeli ktoś by chciał iść w moje ślady, to myślę, że kilka stówek. Podwozie jest najdroższe. Ale jak już ktoś ma wydawać pieniądze na konwersję, to lepiej na budowę od podstaw i zrezygnować z tego shielda, na rzecz sterownika, który uciągnie silniki 4,5A - wtedy nie trzeba szukać silników, które ogarnie shield i parę zł zostaje.

Osobiście, gdyby nie postanowienie zrobienia tego bez dodatkowych nakładów, to pewnie też bym dokupił kilka rzeczy, rezygnując z shielda forbotowego, ale czelendż to czelendż.

Dotarłeś tutaj? No to zobacz krótki filmik.
Podjazd miał nachylenie ok. 30 stopni.

A tutaj cały potworek

//Załączenie bibliotek
#include "DHT.h" //Czujnik temperatury i wilgotności
#include "Servo.h"
#include "Adafruit_MCP23008.h" //Ekspander portów
#include <NewPing.h> //Obsługa HC-SR04

//Ekspander
Adafruit_MCP23008 ekspander;

//Deklaracje i zmienne dla DHT i pomiaru napięcia
#define DHT22_PIN 7 //Pin sygnału z DHT
DHT dht; //Utworzenie obiektu dla czujnika
#define bateria A3
unsigned long czasDHT = 0;
unsigned long odmierzDHT = 0;
unsigned long roznicaDHT = 0;

//Deklaracje serwomechanizmu
Servo serwo;
#define SERWO_PIN 11 //Pin sygnału sterującego PWM
int idle = 84; //Neutralna pozycja dla serwa

//Deklaracje mostek H
#define L_PWM 5 //Pin prędkości lewego silnika
#define L_DIR 4 //Pin kierunku lewego silnika
#define R_PWM 6 //Pin prędkości prawego silnika
#define R_DIR 9 //Pin kierunku prawego silnika
#define PWM_MAX 210 //Maksymalne wypełnienie dla silnika 7,5V przy zasilaniu 9V

//Deklaracje i definicje do obsługi buzzera
#define BUZZER 10
unsigned long aktualnyCzasBuzzer = 0;
unsigned long czasStartuBuzzer = 0;
unsigned long czasTrwaniaBuzzer = 200; // Czas trwania impulsu w milisekundach
boolean buzzerON = false;

//Deklaracje i zmienne czujnika odległości i wykrywania przeszkód
#define LEDjazda 0 //LED informujący o jeździe autonomicznej na 0 pinie ekspandera!!!
#define lewySensor A0 //Krańcówka po lewej
#define prawySensor A1 //Krańcówka po prawej
#define trigPin 12 //Pin nadawczy (szary)
#define echoPin 13 //Pin odbiorczy (biały)
#define MAX_DISTANCE 200  // Maksymalny zasięg w centymetrach
NewPing sonar(trigPin, echoPin, MAX_DISTANCE);  //Inicjalizacja obiektu sonar z użyciem biblioteki NewPing
const int doPrzeszkody = 25; //Odległość wykrywania przeszkody w cm

//Wyliczenie stanów dla jazdy autonomicznej
enum States {
  PROSTO,
  PATRZ_PRAWO,
  OBROT_PRAWO,
  PATRZ_LEWO,
  OBROT_LEWO,
  ZATRZYMAJ,
  ZATRZYMAJ2,
  COFAJ,
  COFAJ_LEWY,
  COFAJ_PRAWY,
};

boolean jazdaAutonomiczna = false;
boolean kolizjaPrawo = false;
boolean kolizjaLewo = false;
static States obecnyStan = PROSTO; //Domyślny stan
unsigned long czasStanu = 0; //Zmienna dla timera stanu
unsigned long czasDotyku = 0; //Zmienna dla timera krańcówek
static unsigned long czasObrotu = 1100; //Zmienna dla czasu trwania obrotu

//Definicje i zmienne dla świateł
#define frontLED 1 //LEDy frontowe na 1 pinie ekspandera!!!
#define stroboLED 2
#define pulsLED 3
int trybLED = 0;
unsigned long czasStrobo = 0;
unsigned long czasLEDstrobo = 0;
int stanStrobo = 0;
int licznikStrobo = 0;
int stanPuls = 0;
unsigned long poprzedniCzasPWM = 0;
unsigned long poprzedniCzasAnimacji = 0;
int wartoscPWM = 0;
int kierunek = 1; // 1 - narastanie, -1 - opadanie
unsigned long interwalZmianyPWM = 10;
unsigned long interwalZmianyKierunku = 750;
unsigned long aktualnyCzasPWM = 0;

void setup() {
  //Konfiguracja ekspandera
  ekspander.begin();
  ekspander.pinMode(LEDjazda, OUTPUT);
  //Konfiguracja świateł
  ekspander.digitalWrite(LEDjazda, LOW);
  pinMode(stroboLED, OUTPUT);
  digitalWrite(stroboLED, stanStrobo);
  pinMode(pulsLED, OUTPUT);
  analogWrite(pulsLED, stanPuls);
  ekspander.pinMode(frontLED, OUTPUT);
  ekspander.digitalWrite(frontLED, LOW);
  //Konfiguracja pinów mostka H
  pinMode(L_DIR, OUTPUT);
  pinMode(L_PWM, OUTPUT);
  pinMode(R_DIR, OUTPUT);
  pinMode(R_PWM, OUTPUT);
  //Konfiguracja pozostałych elementów
  pinMode(bateria, INPUT); //Odczyt ADC dla pomiaru napięcia baterii
  pinMode(lewySensor, INPUT_PULLUP);
  pinMode(prawySensor, INPUT_PULLUP);
  Serial.begin(9600); //Uruchomienie sprzętowej komunikacji UART
  dht.setup(DHT22_PIN); //Podłączenie czujnika do zadeklarowanego pinu
  serwo.attach(SERWO_PIN); //Podłączenie serwa do zadeklarowanego pinu
  serwo.write(idle); //Ustawienie serwa w domyślnej pozycji
  delay(200); //Opóźnienie dla ustabilizowania i przeczekania stanów nieustalonych
  serwo.detach(); //Odłączenie serwa
  //Konfiguracja buzzera i info o zakończeniu setupu
  pinMode(BUZZER, OUTPUT);
  digitalWrite(BUZZER, 1);
  ekspander.digitalWrite(LEDjazda, 1);
  delay(100);
  digitalWrite(BUZZER, 0);
  ekspander.digitalWrite(LEDjazda, 0);
  delay(100);
  digitalWrite(BUZZER, 1);
  ekspander.digitalWrite(LEDjazda, 1);
  delay(100);
  digitalWrite(BUZZER, 0);
  ekspander.digitalWrite(LEDjazda, 0);
  delay(100);
}

void loop() {
  humitemp(); //Wykonuj funkcje DHT
  if(jazdaAutonomiczna) {
    jazdaAuto();
  }
  switch (trybLED) {
    case 0:
    analogWrite(pulsLED, 0);
    digitalWrite(stroboLED, 0);
    ekspander.digitalWrite(frontLED, 0);
    break;

    case 1:
    swiatlaPuls();
    swiatlaStrobo();
    ekspander.digitalWrite(frontLED, 0);
    break;

    case 2:
    swiatlaPuls();
    swiatlaStrobo();
    swiatlaFront();
    break;

    case 3:
    analogWrite(pulsLED, 0);
    digitalWrite(stroboLED, 0);
    swiatlaFront();
    break;

    case 4:
    trybLED = 0;
    break;
  }
  if (buzzerON) {
    klakson();
  }
  if (Serial.available() > 0) { //Jeżeli są dostępne dane BT
    char jazda = Serial.read(); //Odczytaj te dane i przypisz do zmiennej  
      switch(jazda) { //Wykonaj case zgodnie z odebranymi danymi
        case 'F': //Do przodu
          lewySilnik(95);
          prawySilnik(95);
        break;

        case 'B': //Do tyłu
          lewySilnik(-95);
          prawySilnik(-95);
        break;

        case 'S': //Zatrzymaj
          zatrzymajSilniki();
        break;

        case 'L': //Obrót w lewo
          lewySilnik(-80);
          prawySilnik(80);
        break;

        case 'R': //Obrót w prawo
          lewySilnik(80);
          prawySilnik(-80);
        break;

        case 'G': //Lewy łuk do przodu
          lewySilnik(60);
          prawySilnik(95);
        break;

        case 'I': //Prawy łuk do przodu
          lewySilnik(95);
          prawySilnik(60);
        break;

        case 'H': //Lewy łuk do tyłu
          lewySilnik(-60);
          prawySilnik(-95);
        break;

        case 'J': //Prawy łuk do tyłu
          lewySilnik(-95);
          prawySilnik(-60);
        break;

        case 'V': //Impuls buzzerem
          buzzerON = !buzzerON;
          czasStartuBuzzer = millis();
        break;

        case 'X':
          trybLED++;
        break;
        
        case 'A':
          jazdaAutonomiczna = !jazdaAutonomiczna;
          if (!jazdaAutonomiczna) {
            zatrzymajSilniki();
            ekspander.digitalWrite(LEDjazda, 0);
            serwo.detach();
          }
        break;                 
      }    
  }
}

void lewySilnik (int VL) {
    if (VL == 0) return; //Jeżeli wartość VL jest równa zero to nie wykonuj funkcji
    int kierunekLewySilnik = (VL > 0) ? 0 : 1; //Jeżeli wartość VL jest większa od 0 to ustaw wartość 0 (jazda do przodu), jeżeli mniej to ustaw 1 (do tyłu)
    int vlMap = map(abs(VL), 0, 100, 0, PWM_MAX); //Przemapuj zakres PWM do zakresu 0-100, dla ujemnego VL zwróć wartość absolutną
    digitalWrite(L_DIR, kierunekLewySilnik); //Jazda do przodu, albo do tyłu :)
    analogWrite(L_PWM, vlMap); //Ustaw zadaną prędkość
}

void prawySilnik (int VR) {
    if (VR == 0) return; //Jeżeli wartość VL jest równa zero to nie wykonuj funkcji
    int kierunekLewySilnik = (VR > 0) ? 1 : 0; //Jeżeli wartość VR jest większa od 0 to ustaw wartość 1 (jazda do przodu), jeżeli mniej to ustaw 0 (do tyłu)
    int vrMap = map(abs(VR), 0, 100, 0, PWM_MAX); //Przemapuj zakres PWM do zakresu 0-100
    digitalWrite(R_DIR, kierunekLewySilnik); //Jazda do przodu, albo do tyłu :)
    analogWrite(R_PWM, vrMap); //Ustaw zadaną prędkość
}

void zatrzymajSilniki() {
  analogWrite(L_PWM, 0); //Zatrzymaj lewy silnik
  analogWrite(R_PWM, 0); //Zatrzymaj prawy silnik
}

void humitemp () { //Funkcja czujnika DHT22 i pomiar napięcia
  float wilgotnosc = dht.getHumidity(); //Pobierz info o wilgotności do zmiennej
  float temperatura = dht.getTemperature(); //Pobierz info o temperaturze do zmiennej
  float wilgKorekta = wilgotnosc + 1.11; //Procentowa korekta dla odczytu wilgotności
  float tempKorekta = temperatura - 2.35; //Korekta odczytu temperatury
  int adc_val = analogRead(bateria); //Odczytaj wartość ADC
  float Ubat = adc_val * 0.0485340314; //Wylicz wartość napięcia
  czasDHT = millis(); //Pobierz aktualny czas Arduino
  roznicaDHT = czasDHT - odmierzDHT;

  if (roznicaDHT >= 2000UL) { //Jeżeli różnica wyniesie 2000 ms lub więcej
    odmierzDHT = czasDHT; //Zapisz aktualny czas arduino do zmiennej
    if (dht.getStatusString() == "OK") { //Jeżeli czujnik zwróci wartość ok, wykonaj poniższe
      Serial.print(tempKorekta);
      Serial.print(" °C");
      Serial.print("|");
      Serial.print(wilgKorekta);
      Serial.print(" %");
      Serial.print("|");
      Serial.print(Ubat);
      Serial.println(" V");
    }
  }
}

int sonarDystans() {
  int dystans = sonar.ping_cm();  // Wykonanie pomiaru i zapisanie wyniku w zmiennej distance w centymetrach
  return dystans;
}

void swiatlaPuls() {
  aktualnyCzasPWM = millis();
  // Obsługa narastania i opadania PWM
  if (aktualnyCzasPWM - poprzedniCzasPWM >= interwalZmianyPWM) {
    poprzedniCzasPWM = aktualnyCzasPWM;

    wartoscPWM += kierunek; //Zmniana wartości PWM zależna od wartości kiereunku

    if (wartoscPWM >= 255 || wartoscPWM <= 0) {
      if (aktualnyCzasPWM - poprzedniCzasAnimacji >= interwalZmianyKierunku) {
        poprzedniCzasAnimacji = aktualnyCzasPWM;
        kierunek *= -1; // Zmiana kierunku narastania/opadania
      }
    }

    analogWrite(pulsLED, wartoscPWM);
  }
}

void swiatlaStrobo() {
  czasLEDstrobo = millis();
  switch(licznikStrobo) {
    case 0:
      digitalWrite(stroboLED, 1);
      if (czasLEDstrobo - czasStrobo >= 700UL) {
        digitalWrite(stroboLED, 0);
        czasStrobo = czasLEDstrobo;
        licznikStrobo ++;
      }
    break;

    case 13:
      digitalWrite(stroboLED, 0);
      if (czasLEDstrobo - czasStrobo >= 500UL) {
        digitalWrite(stroboLED, 0);
        licznikStrobo ++;
      }
    break;

    default:
      if (czasLEDstrobo - czasStrobo >= 50UL) {
        czasStrobo = czasLEDstrobo;
        stanStrobo = !stanStrobo;
        digitalWrite(stroboLED, stanStrobo);
        licznikStrobo ++;
      }
    break;
  }
  if (licznikStrobo > 13) {
    licznikStrobo = 0;
  }
}

void swiatlaFront() {
  ekspander.digitalWrite(frontLED, 1);
}

void jazdaAuto() { //Funkcja jazdy autonomicznej
  ekspander.digitalWrite(LEDjazda, 1); //Włącz LED informujący o jeździe autonomicznej

  switch (obecnyStan) {
    case PROSTO:
      prosto();
    break;

    case ZATRZYMAJ:
      zatrzymaj();
    break;

    case ZATRZYMAJ2:
      zatrzymaj2();
    break;

    case PATRZ_PRAWO: //Wykrywanie przeszkód po prawej
      patrzPrawo();
    break;
      
    case OBROT_PRAWO: //Skręt w prawo
      obrotPrawo();
    break;

    case PATRZ_LEWO: //Wykrywanie przeszkód po lewej
      patrzLewo();
    break;

    case OBROT_LEWO: //Skręt w lewo
      obrotLewo();
    break;

    case COFAJ:
      cofaj();
    break;

    case COFAJ_LEWY:
      cofajLewy();
    break;
    
    case COFAJ_PRAWY:
      cofajPrawy();
    break;
  }

  if (digitalRead(lewySensor) == LOW && kolizjaLewo==0) { //Jeżeli przeszkoda po lewej
    kolizjaLewo = 1;
    obecnyStan = COFAJ_LEWY;
    czasStanu = millis();
  }
  
  if (digitalRead(prawySensor) == LOW && kolizjaPrawo==0) { //Jeżeli przeszkoda po prawej
    kolizjaPrawo = 1;
    obecnyStan = COFAJ_PRAWY;
    czasStanu = millis(); 
  }            
}

void prosto() {
  if (sonarDystans() <= doPrzeszkody) { //Jeżeli w zadanej odległości jest przeszkoda
    obecnyStan = ZATRZYMAJ; //Przejdź do zatrzymania
    czasStanu = millis(); //Ustaw czas dla timera
    serwo.attach(SERWO_PIN); //Podłącz serwo
    } else { //Jedź prosto
        lewySilnik(90);
        prawySilnik(90);
      }
}

void zatrzymaj() {
  zatrzymajSilniki();
    if (millis() - czasStanu >= 500UL) { //Odczekaj zadany czas
      obecnyStan = PATRZ_PRAWO; //Przejdź do wykrywania przeszkody po prawej
      czasStanu = millis();
    }
}

void zatrzymaj2() {
  zatrzymajSilniki();
    if (millis() - czasStanu >= 500UL) {
      obecnyStan = PATRZ_LEWO; //Przejdź do wykrywania przeszkody po prawej
      czasStanu = millis();
    }
}

void patrzPrawo() {
  serwo.write(25); //Ustw serwo w prawo
    if (millis() - czasStanu >= 400UL) { //Patrz przez zadany czas dla ustabilizowania serwa
      if (sonarDystans() > doPrzeszkody) { //Jeżeli nie ma przeszkód bliżej niż zadana odległość
        obecnyStan = OBROT_PRAWO; //Skręć w prawo
        czasStanu = millis(); //Ustaw czas dla timera
      } else { //Jeżeli jest przeszkoda
        obecnyStan = PATRZ_LEWO; //Przejdź do wykrywania przeszkody po lewej
        czasStanu = millis(); //Ustaw czas dla timera
      }
    }
}

void obrotPrawo() {
  lewySilnik(70);
  prawySilnik(-70);
  serwo.write(idle); //Ustaw serwo na wprost      
    if (millis() - czasStanu >= czasObrotu) { //Skręcaj przez zadany czas
      serwo.detach();
      obecnyStan = PROSTO; //Przejdź do jazdy na prosto
      czasStanu = millis(); //Ustaw czas dla timera
    }
}

void patrzLewo() {
  serwo.write(155); //Obróć serwo w lewo
    if (millis() - czasStanu >= 450UL) { //Patrz przez zadany czas dla ustabilizowania serwa
      if (sonarDystans() > doPrzeszkody) { //Jeżeli nie ma przeszkody w zadanej odległości
        obecnyStan = OBROT_LEWO; //Skręć w lewo
        czasStanu = millis(); //Ustaw czas dla timera
      } else { //Jeżeli jest przeszkoda
        obecnyStan = COFAJ; //Włącz alarm
        czasStanu = millis(); //Ustaw czas dla timera
      }
    }
}

void obrotLewo() {
  lewySilnik(-70);
  prawySilnik(70);
  serwo.write(idle); //Ustaw serwo na wprost
    if (millis() - czasStanu >= czasObrotu) { //Skręcaj przez zadany czas
      serwo.detach();
      obecnyStan = PROSTO; //Przejdź do jazdy prosto
      czasStanu = millis(); //Ustaw czas dla timera
    }
}

void cofaj() {
  serwo.write(idle); //Ustaw serwo na wprost
  lewySilnik(-80); //cofaj
  prawySilnik(-80);
    if (millis() - czasStanu >= 800UL) { //Po upływie zadanego czasu
      zatrzymajSilniki(); //Zatrzymaj się
      obecnyStan = ZATRZYMAJ; //Przejdź do jazdy prosto
      czasStanu = millis(); //Ustaw czas dla timera
    }
}

void cofajLewy() {
  lewySilnik(-70);
  prawySilnik(-70);
    if (millis() - czasStanu >= 800UL) {
    obecnyStan = ZATRZYMAJ; //Przejdź do wykrywania przeszkody po prawej
    czasStanu = millis();
    kolizjaLewo = 0;
    }
}

void cofajPrawy() {
  lewySilnik(-70);
  prawySilnik(-70);
    if (millis() - czasStanu >= 800UL) {
      obecnyStan = ZATRZYMAJ2; //Przejdź do wykrywania przeszkody po prawej
      czasStanu = millis();
      kolizjaPrawo = 0;
    }
}

void klakson() {
  aktualnyCzasBuzzer = millis();
  if (aktualnyCzasBuzzer - czasStartuBuzzer < czasTrwaniaBuzzer) {
      digitalWrite(BUZZER, HIGH);
    } else {
      digitalWrite(BUZZER, LOW);
      buzzerON = false;
    }
}

Treker · Wrzesień 4, 2023

@Danyeru dzięki za opis ciekawego projektu Miło widzieć, że robot z kursu nie poszedł w kąt i przeszedł taką metamorfozę. Może z oryginału został tylko shield... ale zakładam, że nadal można to traktować jako rozbudowę forbotowego robota Powodzenia podczas tworzenia kolejny projektów

Danyeru · Wrzesień 4, 2023

@Treker jak wspomniałem, miało być tylko BT, ale szuflada okazała się kopalnią skarbów, a jedna zmiana ciągnęła za sobą kolejne.
Natomiast wykorzystując zdobytą wiedzę, niewykorzystane części robota i podzespoły z pierwszej części kursu Arduino forbociak odżyje, bo najmłodsza część rodziny chce mieć swojego robota sterowanego z telefonu.