Skocz do zawartości
Komentator

Kurs budowy robotów - #8 - zdalne sterowanie IR (RC5)

Pomocna odpowiedź

RC5 jest wrażliwe na wszelkie opóźnienia w programie, więc postaraj się unikać wszelkich delayi. Możesz skorzystć z funkcji millis i przygotować nieblokujące obliczanie czasu w którym ma nastąpić przełączenie kolorów LED i dodać zmienną służącą jako przełącznik w styl: jak true to migaj jak false to nie migaj.

Udostępnij ten post


Link to post
Share on other sites
(edytowany)

Część, ominąłem póki co line followera bo chciałem połączyć zdalne sterowanie ze światłolubem oraz omijaniem przeszkód. Obecnie robot może być sterowany zdalnie, z możliwością płynnej regulacji prędkości jazdy. Osiągnięcie zarówno wartości maksymalnej jak i minimalnej sygnalizowane jest BUZZERem. Odpowiadają za to przyciski "vol up" oraz "vol down" na pilocie. Przycisk source natomiast powoduje zmianę trybu jazdy. W drugim trybie jazdy robot jeździ autonomicznie omijając przeszkody. Z przodu, jak poprzednio, przeszkody wykrywa za pomocą "czułek". Z tyłu posiada również czujnik ultradźwiękowy, który pozwala uniknąć tratowania obiektów za robotem podczas zawracania. W dowolnym momencie jednym kliknięciem mogę się przełączać między trybami. Zmiana trybu również sygnalizowana jest przez piknięcie BUZZERa.

Kod:

#include <Arduino.h>
#define TSOP_PIN 3
#define L_PWM 5
#define L_DIR 4
#define R_PWM 6
#define R_DIR 9
#define R_LIGHT_SENSOR A0
#define L_LIGHT_SENSOR A1
#define L_SIDE_SENSOR A2
#define R_SIDE_SENSOR 12
#define ROZNICA_MIN -400
#define ROZNICA_MAX 400
#define PWM_MAX 165
#define trigPin 8
#define echoPin 7

#define BUZZER 10
#define LED 13

#include <RC5.h>

RC5 rc5(TSOP_PIN); //ifnormcaja o podłączeniu odbiornika

//zmienne dla RC5
byte address;
byte command;
byte toggle;
int predkosc = 40; //zmienna poczatkowa dla predkosci
bool ZmianaTrybu = false; //zmienna dla określenia trybu jazdy


void setup() {
  

  pinMode(L_DIR, OUTPUT); //konfiguracja pinów dla mostka H
  pinMode(R_DIR, OUTPUT);
  pinMode(L_PWM, OUTPUT);
  pinMode(R_PWM, OUTPUT);

  pinMode(BUZZER, OUTPUT); //konfiguracja pozostałych elementów
  digitalWrite(BUZZER, 0);
  pinMode(LED, OUTPUT);
  digitalWrite(LED, 0);
  pinMode(L_SIDE_SENSOR, INPUT_PULLUP); //koniguracja pinu jak przyckiski
  pinMode(R_SIDE_SENSOR, INPUT_PULLUP);
  randomSeed(analogRead(5)); //inicjalizacja generatora liczb losowych
  pinMode(trigPin, OUTPUT); //Deklaracja pinów dla czujnika zbliżeniowego
  pinMode(echoPin, INPUT);

}

void loop() {
  
  if (ZmianaTrybu == false) { //sprawdzenie obecnego trybu jazdy

    if (rc5.read(&toggle, &address, &command)) { //jeśli odebrano komendę
    switch(command) {
      case 12:
        digitalWrite(BUZZER, 1);
        delay(500);
        digitalWrite(BUZZER, 0);
      break;
      
      case 2: //do przodu
        leftMotor(predkosc);
        rightMotor(predkosc);
      break;

      case 4: //obrot w lewo
        leftMotor(-(predkosc-10));
        rightMotor(predkosc-10);
      break;

      case 5: //stop
        StopMotors();
      break;

      case 6: //w prawo
        leftMotor(predkosc-10);
        rightMotor(-(predkosc-10));
      break;

      case 8: //do tyłu
        leftMotor(-predkosc);
        rightMotor(-predkosc);
      break;

      case 3: //łuk w prawo do przodu
        leftMotor(predkosc);
        rightMotor(predkosc-20);
      break;

      case 1: //łuk w lewo do przodu
        leftMotor(predkosc-20);
        rightMotor(predkosc);
      break;

      case 7: //łuk w lewo do tyłu 
        leftMotor(-(predkosc-20));
        rightMotor(-predkosc);
      break;

      case 9: //łuk w prawo do tyłu
        leftMotor(-predkosc);
        rightMotor(-(predkosc-20));
      break;

      case 16: //zwiekszenie predkosci jazdy
        if (predkosc < 80) { //okreslenie maksymalnej dopuszczalnej predkosci
          predkosc++;
        } else {
            sygnalizacjaBuzzer(4);
          }
       break;

       case 17: //zmniejszenie predkosci jazdy
       if (predkosc > 40) { //okreslenie minimalnej dopuszczalnej predkosci
           predkosc--;
       } else {
           sygnalizacjaBuzzer(4);
       }
       break;

       case 56:

          ZmianaTrybu = !ZmianaTrybu;
          sygnalizacjaUruchomienia();
        break;
        
    }
  } 
  } else { //cześć dla światłoluba oraz omijania przeszkód
    int odczytLewy = analogRead(L_LIGHT_SENSOR); //odczytanie wartości z lewego czujnika
    int odczytPrawy = analogRead(R_LIGHT_SENSOR); //odczytanie wartości z prawego czujnika
    int roznica = odczytLewy - odczytPrawy;
    int los = random(5, 40) * 10; //wylosowanie liczby dla czasu obrotu
    int randomSpeed = random(2, 6) * 10; //wylosowanie predkosci jazdy do przodu

    if (roznica < ROZNICA_MIN) { //ewentualna korekcja skrajnych warotści róznic
        roznica = ROZNICA_MIN;
    } else if (roznica > ROZNICA_MAX) {
        roznica = ROZNICA_MAX;
    }

	int zmianaPredkosci = map(roznica, ROZNICA_MIN, ROZNICA_MAX, -40, 40);
	//zmienna pozawalająca przeliczenie odczytów z czuników na zmianę prędkości silników
      
      leftMotor(30+zmianaPredkosci); //korekty prędkości zależnie od natężenia światła
      rightMotor(30-zmianaPredkosci);

      if (digitalRead(L_SIDE_SENSOR) == LOW)
    { //jeśli przeszkoda zostanie wykryta po lewej stronie
     
        int odleglosc = zmierzOdlegosc(); //zmienna odczytująca dystans z czujnika US
 
        if (odleglosc > 30) //jeśli odległość jest większa niż 30 cm to robot zdąży wykonać pełny zadany ruch
        {
            leftMotor(-40);
            rightMotor(-40);
            digitalWrite(BUZZER, 1);
            delay(1000);
        }
        else
        {
            while (odleglosc > 8) //jeśli odległość mniejsza niż 30 cm sprawdzanie kolejnych odległości do momentu osiągnięcia wartości 8 cm
            {
 
                leftMotor(-40);
                rightMotor(-40);
                digitalWrite(BUZZER, 1);
                odleglosc = zmierzOdlegosc(); //zamiana wartości odległości
                delay(50);
 
            }
        }
 
        //obrót w miejscu w prawo
        leftMotor(randomSpeed);
        rightMotor(-randomSpeed);
        digitalWrite(BUZZER, 0);
        delay(150 + los);
        //koniec warunku, wracamy do jazdy prosto
 
    }
 
    if (digitalRead(R_SIDE_SENSOR) == LOW)
    { //jeśli przeszkoda zostanie wykryta po prawej stronie
      //jedź wstecz i wydawaj dźwięk
        int odleglosc = zmierzOdlegosc(); //powtarzamy co w poprzednim warunku
 
        if (odleglosc > 30)
        {
            leftMotor(-40);
            rightMotor(-40);
            digitalWrite(BUZZER, 1);
            delay(1000);
        }
        else
        {
            while (odleglosc > 8)
            {
 
                leftMotor(-40);
                rightMotor(-40);
                digitalWrite(BUZZER, 1);
                odleglosc = zmierzOdlegosc();
                delay(50);
 
            }
        }
        //obrót w miejscu w lewo
        leftMotor(-randomSpeed);
        rightMotor(randomSpeed);
        digitalWrite(BUZZER, 0);
        delay(150 + los);
        //koniec warunku, wracamy do jazdy prosto
 
    }
    
    TrybJazdy(); //funckja odpowiedzialna za zmianę trybu pracy

  }

}

void leftMotor(int V) { //funkcja odpowiedzialna za sterowanie lewym silnikiem
  if (V > 0) { //jeśli wartość prędkości więszka od 0
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(L_DIR, 0); //do przodu
    analogWrite(L_PWM, V); //zadanie prędkości
  } else {
    V = abs(V); //wyciągnięcie wartości bezwzględnej
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(L_DIR, 1); //do tyłu
    analogWrite(L_PWM, V); //zadanie prędkości   
  }
}

void rightMotor(int V) { //to samo co wyżej tylko dla prawego
    if (V > 0) {
        V = map(V, 0, 100, 0, PWM_MAX);
        digitalWrite(R_DIR, 0);
        analogWrite(R_PWM, V);
    } else {
        V = abs(V);
        V = map(V, 0, 100, 0, PWM_MAX);
        digitalWrite(R_DIR, 1);
        analogWrite(R_PWM, V);
    }
}

void StopMotors() { //zatrzymanie silników 
    analogWrite(L_PWM, 0);
    analogWrite(R_PWM, 0);
}

void sygnalizacjaBuzzer(int powtorzenia) {
    int i = 0; 
    for (i = 0; i < powtorzenia; i++) {
        digitalWrite(BUZZER, HIGH);
        delay(200);
        digitalWrite(BUZZER, LOW);
        delay(200);
    }
}

void sygnalizacjaUruchomienia() { //sygnalizacja dźwiękowa startu
    
 int i = 0; 
    for (i; i < 3; i++) { 
        digitalWrite(BUZZER, HIGH);
        delay(200);
        digitalWrite(BUZZER, LOW);
         delay(200);
    }
}


int zmierzOdlegosc() //funkcja dla mierzenia odległości przez czujnik SC
{
    long czas, dystans;
 
    digitalWrite(trigPin, LOW);
    delayMicroseconds(2);
    digitalWrite(trigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(trigPin, LOW);
 
    czas = pulseIn(echoPin, HIGH);
    dystans = czas / 58;
 
    return dystans;
}

void TrybJazdy() { //funckja odpowidzialna za zmianę trybu jazdy
     if (rc5.read(&toggle, &address, &command)) {
       switch(command) {
           case 56:
            ZmianaTrybu = !ZmianaTrybu;
            StopMotors();
            sygnalizacjaUruchomienia();
        break;
       } 
    }

  } 
  

oraz krótki film z działania: 

 

Edytowano przez BHBmacieg
  • Lubię! 1

Udostępnij ten post


Link to post
Share on other sites

Super! Fajnie że porządnie zabierasz się za wszystkie zadania i dodajesz coś od siebie. Powodzenia w dalszych projektach i chętnie zobaczę kolejne postępy 🙂 

Udostępnij ten post


Link to post
Share on other sites
(edytowany)

Dzień Dobry,

Mam małą zagwozdkę odnośnie zmiennych globalnych.

Bardzo proszę o wyjaśnienie mi poniższego prostego zresztą kodu:

#include <RC5.h>
#define TSOP_PIN 3
RC5 rc5(TSOP_PIN);
byte address;
byte command;
byte toggle;

int robotMode = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  if (rc5.read(&toggle, &address, &command)) {
    switch (command) {
      case 10:
        robotMode = 1;
        break;
      case 146:
        robotMode = 0;
        break;
    }
    Serial.println("Tryb pracy robota: " + String(robotMode) + " Tutaj widać zmieniona wartosc zmiennej globalnej!!!");
    delay(300);
  }
  //Serial.println("Tryb pracy robota: " + String(robotMode) + " Tutaj nie widać zmienionej wartosci zmiennej globalnej!!!");
  //delay(300);
}

W pierwszej kolejności proszę uruchomić kod w takiej postaci w jakiej go tutaj umieściłem a potem za komentować Serial i delay wewnątrz instrukcji if i od komentować Serial i delay poza instrukcją if. 

Dlaczego wewnątrz ciała instrukcji if zmienna ulega zmianie podczas gdy poza tą instrukcją ta zmiana nie obowiązuje?

Edytowano przez Gieneq
Zachęcam do używania bloku kodu

Udostępnij ten post


Link to post
Share on other sites
(edytowany)

Możliwe że delay powoduje problemy. W programach z RC5 nie powinno się tworzyć większych opóźnień, bo potrafią uniemożliwić odbiór.

A czym objawia się to, że nie widać zmiennej? Możesz opisać jakie wartości otrzymujesz a jakie byś oczekiwał przy konkretnych naciśnięciach przycisku?

Edytowano przez Gieneq

Udostępnij ten post


Link to post
Share on other sites

Witam!

Podobnie jak kolega cztery wpisy wyżej połączyłem trzy tryby działania robota, wybór trybu sygnalizowany jest mignięciem diody oraz buzzerem. Aby robot zaczął działać po wybraniu trybu trzeba jeszcze go "włączyć pilotem". Oczywiście w trakcie działania można go pilotem wyłączyć. W trybach światłolub i ręcznie sterowanie w przypadku wykrycia przeszkody robot się cofnie i zatrzyma. Klawiszem od regulacji głośności można również zwiększyć i zmniejszyć prędkość robota.

#include <RC5.h>

//ustawienia silnikow
#define PWM_MAX 165 //maksymalne obroty przy zasilaniu 9V
#define L_PWM 5     //obroty silnika lewego
#define L_DIR 4     //kierunek silnika lewego
#define R_PWM 6     //obroty silnika prawego
#define R_DIR 9     //kierunek silnika prawego

//sensory - wąsy
#define L_SIDE_SENSOR A2
#define R_SIDE_SENSOR 7

//sensory - czujnik światła
#define L_LIGHT_SENSOR A1
#define R_LIGHT_SENSOR A0

//glosnik
#define BUZZER 10

//dioda
#define LED 13

//odbiornik IR
#define TSOP_PIN 3

//przekazanie na jakim pinie jest odbiornik IR
RC5 rc5(TSOP_PIN);

//zmienne dla RC5
byte address;
byte command;
byte toggle;

//tryby działania
const String tryb1 = "OMIJANIE_PRZESZKOD";
const String tryb2 = "SWIATLOLUB";
const String tryb3 = "STEROWANIE_IR";
//zmienna do ustalenia w jakim trybie działa robot, domyslnie tryb3 sterowanie IR
String trybDzialania = tryb3;

//zmienne do kierowania robotem
boolean jazda = false;
int los = 5; //do losowego czasu trwania obrotu przy przeszkodzie
int kierunek = 5;
int predkosc = 50;
#define V_MAX 80
#define V_MIN 30

//zmienne do trybu światłolub
int odczytLewy = 0;
int odczytPrawy = 0;
int roznicaSwiatla = 0;
int zmianaPredkosci = 0;
#define ROZNICA_MIN -300
#define ROZNICA_MAX 300

void setup()
{
  //Konfiguracja pinow mostku H
  pinMode(L_DIR, OUTPUT);
  pinMode(R_DIR, OUTPUT);
  pinMode(L_PWM, OUTPUT);
  pinMode(R_PWM, OUTPUT);

  //konfiguracja pinow od sensorów - wąsy
  pinMode(L_SIDE_SENSOR, INPUT_PULLUP);
  pinMode(R_SIDE_SENSOR, INPUT_PULLUP);

  //Konfiguracja pozostalych elementow
  pinMode(BUZZER, OUTPUT);
  digitalWrite(BUZZER, 0); //buzzer wylaczony
  pinMode(LED, OUTPUT);
  digitalWrite(LED, 0); //wylaczenie diody

  //inicjalizacja generatora liczb pseudolosowych
  randomSeed(analogRead(A5));

  //Serial.begin(9600);
}

void loop()
{
  //jeśli odebrano dane, reakcja na przyciski pilota
  if (rc5.read(&toggle, &address, &command))
  {
    switch (command)
    {

      case 12: // właczanie/wyłączanie silnikow
        if (jazda == false)
        {
          jazda = true;
          zapalDiode(LED);
          zatrzymajRobota();
          delay(500);
        }
        else
        {
          jazda = false;
          zgasDiode(LED);
          zatrzymajRobota();
          delay(500);
        }
        break;

      case 16: //zwiekszanie predkosci
        if (predkosc < V_MAX)
        {
          predkosc = predkosc + 5;
          //Serial.println(predkosc);
        }
        break;

      case 17: //zmiejszanie predkosci
        if (predkosc > V_MIN)
        {
          predkosc = predkosc - 5;
          //Serial.println(predkosc);
        }
        break;

      case 1: //skret w lewo do przodu
        kierunek = 1;
        break;

      case 2: //do przodu
        kierunek = 2;
        break;

      case 3: //skret w prawo do przodu
        kierunek = 3;
        break;

      case 4: //obrot w lewo
        kierunek = 4;
        break;

      case 5: //stop
        zatrzymajRobota();
        break;

      case 6: //obrot w prawo
        kierunek = 6;
        break;

      case 7: //skret w lewo do tyłu
        kierunek = 7;
        break;

      case 8: //do tylu
        kierunek = 8;
        break;

      case 9: //skret w prawo do tylu
        kierunek = 9;
        break;

      case 35: //wlacz diode
        zapalDiode(LED);
        break;

      case 62: //wylacz diode
        zgasDiode(LED);
        break;

      case 36: //klakson
        klaskonON(BUZZER);
        delay(200);
        klaksonOFF(BUZZER);
        break;

      //wybór trybów działania robota
      case 107:
        jazda = false;
        zatrzymajRobota();
        for (int i = 0; i < 1; i++)
        {
          zapalDiode(LED);
          klaskonON(BUZZER);
          delay(100);
          zgasDiode(LED);
          klaksonOFF(BUZZER);
          delay(100);
        }
        trybDzialania = tryb1;
        break;

      case 108:
        jazda = false;
        zatrzymajRobota();
        for (int i = 0; i < 2; i++)
        {
          zapalDiode(LED);
          klaskonON(BUZZER);
          delay(100);
          zgasDiode(LED);
          klaksonOFF(BUZZER);
          delay(100);
        }
        trybDzialania = tryb2;
        break;

      case 109:
        jazda = false;
        zatrzymajRobota();
        for (int i = 0; i < 3; i++)
        {
          zapalDiode(LED);
          klaskonON(BUZZER);
          delay(100);
          zgasDiode(LED);
          klaksonOFF(BUZZER);
          delay(100);
        }
        trybDzialania = tryb3;
        break;
    }
  }

  //jesli jazda == true, tryb1 - jedz reagujac na przeszkody
  if (jazda == true && trybDzialania == "OMIJANIE_PRZESZKOD")
  {
    //jazda do przodu
    jedzDoPrzodu(predkosc);
    los = random(5, 20) * 10; //czs obrotu miedzy 50 a 200 ms

    //przeszkoda po lewej stronie
    if (digitalRead(L_SIDE_SENSOR) == LOW)
    {
      jedzDoTylu(predkosc);
      klaskonON(BUZZER);
      delay(300);
      obrotPrawo(predkosc - 10);
      klaksonOFF(BUZZER);
      delay(140 + los);
    }

    //przeszkoda po prawej stronie
    if (digitalRead(R_SIDE_SENSOR) == LOW)
    {
      jedzDoTylu(predkosc);
      klaskonON(BUZZER);
      delay(300);
      obrotLewo(predkosc - 10);
      klaksonOFF(BUZZER);
      delay(140 + los);
    }
  }

  //jesli jazda == true, tryb2 - światłolub
  if (jazda == true && trybDzialania == "SWIATLOLUB")
  {
    odczytLewy = analogRead(L_LIGHT_SENSOR);
    odczytPrawy = analogRead(R_LIGHT_SENSOR);

    roznicaSwiatla = odczytLewy - odczytPrawy;

    //czy nie przekracza max
    if (roznicaSwiatla < ROZNICA_MIN)
    {
      roznicaSwiatla = ROZNICA_MIN;
    }
    else if (roznicaSwiatla > ROZNICA_MAX)
    {
      roznicaSwiatla = ROZNICA_MAX;
    }

    //przeliczamy roznice w jasnosci na zmiane predkosci
    zmianaPredkosci = map(roznicaSwiatla, ROZNICA_MIN, ROZNICA_MAX, -predkosc, predkosc);

    skretSwLub(predkosc, zmianaPredkosci);

    //jesli natrafil na przeszkode wydaj dzwiek cofnij, zatrzymaj i 'wyłacz' robota
    if (digitalRead(L_SIDE_SENSOR) == LOW || digitalRead(R_SIDE_SENSOR) == LOW)
    {
      kierunek = 5;
      jazda = false;
      zgasDiode(LED);
      klaskonON(BUZZER);
      jedzDoTylu(predkosc);
      delay(500);
      klaksonOFF(BUZZER);
      stopSilniki();
    }
  }

  // jesli jazda == true, tryb3 - jedź zdodnie z danymi z pilota
  if (jazda == true && trybDzialania == "STEROWANIE_IR")
  {
    switch (kierunek)
    {
      case 1: //skret w lewo do przodu
        skretLewo(predkosc);
        break;

      case 2: //do przodu
        jedzDoPrzodu(predkosc);
        break;

      case 3: //skret w prawo do przodu
        skretPrawo(predkosc);
        break;

      case 4: //obrot w lewo
        obrotLewo(predkosc - 10);
        break;

      case 5: //stop
        stopSilniki();
        break;

      case 6: //obrot w prawo
        obrotPrawo(predkosc - 10);
        break;

      case 7: //skret w lewo do tyłu
        skretLewo(-predkosc);
        break;

      case 8: //do tylu
        jedzDoTylu(predkosc);
        break;

      case 9: //skret w prawo do tylu
        skretPrawo(-predkosc);
        break;
    }

    //jesli natrafil na przeszkode wydaj dzwiek cofnij i zatrzymaj
    if (digitalRead(L_SIDE_SENSOR) == LOW || digitalRead(R_SIDE_SENSOR) == LOW)
    {
      kierunek = 5;
      klaskonON(BUZZER);
      jedzDoTylu(predkosc);
      delay(500);
      klaksonOFF(BUZZER);
      stopSilniki();
    }
  }
}

//funcje sterujace robotem
void lewySilnik(int V)
{
  if (V > 0)
  {
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(L_DIR, 0); //kierunek do przodu
    analogWrite(L_PWM, V);  //ustawienie predkosci
  }
  else
  {
    V = abs(V);
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(L_DIR, 1); //kierunek do tylu
    analogWrite(L_PWM, V);  //ustawienie predkosci
  }
}

void prawySilnik(int V)
{
  if (V > 0)
  {
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(R_DIR, 0); //kierunek do przodu
    analogWrite(R_PWM, V);  //ustawienie predkosci
  }
  else
  {
    V = abs(V);
    V = map(V, 0, 100, 0, PWM_MAX);
    digitalWrite(R_DIR, 1); //kierunek do tylu
    analogWrite(R_PWM, V);  //ustawienie predkosci
  }
}

void stopSilniki()
{
  analogWrite(L_PWM, 0);
  analogWrite(R_PWM, 0);
}

void jedzDoPrzodu(int V)
{
  lewySilnik(V);
  prawySilnik(V);
}

void jedzDoTylu(int V)
{
  lewySilnik(-V);
  prawySilnik(-V);
}

void obrotLewo(int V)
{
  lewySilnik(-V);
  prawySilnik(V);
}

void obrotPrawo(int V)
{
  lewySilnik(V);
  prawySilnik(-V);
}

void skretLewo(int V)
{
  lewySilnik(V / 2);
  prawySilnik(V);
}

void skretPrawo(int V)
{
  lewySilnik(V);
  prawySilnik(V / 2);
}

void skretSwLub(int V, int zV)
{
  lewySilnik(V + zV);
  prawySilnik(V - zV);
}
void zatrzymajRobota()
{
  kierunek = 5;
  stopSilniki();
}

//funkcje pomocnicze

//zapalanie diody
void zapalDiode(int PIN)
{
  digitalWrite(PIN, 1);
}
//gaszenie diody
void zgasDiode(int PIN)
{
  digitalWrite(PIN, 0);
}
//włacznie buzzera
void klaskonON(int PIN)
{
  digitalWrite(PIN, 1);
}
//wylaczenie buzzera
void klaksonOFF(int PIN)
{
  digitalWrite(PIN, 0);
}

Tutaj robot we wszystkich trzech trybach:

 

  • Lubię! 2

Udostępnij ten post


Link to post
Share on other sites

@Vesley33 super, dobra robota - radzi sobie bardzo fajnie! Powodzenia w dalszych eksperymentach z Arduino i robotyką 😉

Udostępnij ten post


Link to post
Share on other sites

Podłączyłem baterie do pilota, napisałem program i próbuje testować... zero reakcji... Pomyślałem że pewnie coś zasłania odbiornik IR więc sprawdzam i szczęka mi opadła... Na płytce nie ma odbiornika IR... nie został wlutowany:/ Bawiąc się wcześniej nie zwróciłem na to uwagi...

Zgłosiłem reklamacje do botland i czekam na reakcje. To tak w ramach ciekawostek i ponarzekania.

Dzięki za kurs i poświęcony czas:) Będzie kolejny bardziej zaawansowany cykl...? @Treker może coś więcej o line followerach... pisałeś że lubisz...🙂

Udostępnij ten post


Link to post
Share on other sites

@HanulaM oj to nie dobrze, takiej reklamacji jeszcze nie było. Przepraszam za zamieszanie i dziękuję za sygnał - sprawdzę to jeszcze dokładniej po swojej stronie.

22 godziny temu, HanulaM napisał:

Dzięki za kurs i poświęcony czas:) Będzie kolejny bardziej zaawansowany cykl...? @Treker może coś więcej o line followerach... pisałeś że lubisz...🙂

Na ten moment nie mam w planach kolejnego kursu o robotach, ale na pewno kiedyś się za to wezmę, bo faktycznie swego czasu sporo działałem z linefollowerami 😉

  • Lubię! 1

Udostępnij ten post


Link to post
Share on other sites

Dołącz do dyskusji, napisz odpowiedź!

Jeśli masz już konto to zaloguj się teraz, aby opublikować wiadomość jako Ty. Możesz też napisać teraz i zarejestrować się później.
Uwaga: wgrywanie zdjęć i załączników dostępne jest po zalogowaniu!

Anonim
Dołącz do dyskusji! Kliknij i zacznij pisać...

×   Wklejony jako tekst z formatowaniem.   Przywróć formatowanie

  Dozwolonych jest tylko 75 emoji.

×   Twój link będzie automatycznie osadzony.   Wyświetlać jako link

×   Twoja poprzednia zawartość została przywrócona.   Wyczyść edytor

×   Nie możesz wkleić zdjęć bezpośrednio. Prześlij lub wstaw obrazy z adresu URL.


×
×
  • Utwórz nowe...