Forumowy Moduł Świateł

Regulatory, sterowniki, serwa, pakiety itp.
Awatar użytkownika
wajha1983
Kierowca
Posty: 4882
Rejestracja: 10 lis 2013, 16:21
Has thanked: 16 times
Been thanked: 10 times

Re: Forumowy Moduł Świateł

Post autor: wajha1983 »

Troche poprawilem ;)
Musze czekac do nastepengo weekendu zeby moc to sprawdzic czy dziala :decha :krzyk
void setup() {
  // put your setup code here, to run once:

}/*

██████╗  ██████╗████████╗██████╗ ██╗   ██╗ ██████╗██╗  ██╗   ██████╗ ██╗
██╔══██╗██╔════╝╚══██╔══╝██╔══██╗██║   ██║██╔════╝██║ ██╔╝   ██╔══██╗██║
██████╔╝██║        ██║   ██████╔╝██║   ██║██║     █████╔╝    ██████╔╝██║
██╔══██╗██║        ██║   ██╔══██╗██║   ██║██║     ██╔═██╗    ██╔═══╝ ██║
██║  ██║╚██████╗   ██║   ██║  ██║╚██████╔╝╚██████╗██║  ██╗██╗██║     ███████╗
╚═╝  ╚═╝ ╚═════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝  ╚═════╝╚═╝  ╚═╝╚═╝╚═╝     ╚══════╝

RCTRUCK.PL SN: #1001 v2.0 21/12/2016

Oryginalne źródło :           http://rctruck.pl/forum/viewtopic.php?f=37&t=3457
Oryginalny firmware :         by Slawek K. (unix@rctruck.pl)


Schemat & Strona projectu :   http://rctruck.pl/forum/viewtopic.php?f=37&t=3457
*/

// WEJŚCIA
#define GAZ 9
#define SKRET 8
#define AUX 7
#define HALOGEN 5


// WYJŚCIA
#define PRZEDNIE 2
#define TYLNE 3
#define LEWY 1
#define PRAWY 6
#define HALOGEN 0
#define WSTECZNE 10
#define BUZZER 4
#define HALOGEN 11
#define HALOGEN 12
#define HALOGEN 13


int lewyStatus = 0;
int prawyStatus = 0;
int awaryjneStatus = 0;
int bladStatus = 0;

unsigned long poprzedni_lewy = 0;
unsigned long poprzedni_prawy = 0;
unsigned long poprzedni_awaryjne = 0;
unsigned long poprzedni_hamulec = 0;
unsigned long poprzedni_blad = 0;
unsigned long aktualny_hamulec = 0;

const long przerwa_kierunkowskazy = 500;
const int przerwa_blad = 500;
const long dlugosc_hamulec = 3000;

int maxPulse = 2000;
int minPulse = 1000;
int srodekPulse = 1500;
int neutrum = 250;

int zaswiec_stop = 0;

unsigned long gaz_odczyt = 0;
unsigned long skret_odczyt = 0;
unsigned long aux_odczyt = 0;

int gaz_stan = 0;
int ostatni_gaz_stan = 0;

boolean awaryjne_blokada = false;
int proces = 0;



void setup() {

pinMode(GAZ, INPUT);
pinMode(SKRET, INPUT);
pinMode(AUX, INPUT);
pinMode(HALOGEN, INPUT);
pinMode(BUZZER, OUTPUT);
noTone(BUZZER);

pinMode(PRZEDNIE, OUTPUT);
pinMode(TYLNE, OUTPUT);
pinMode(LEWY, OUTPUT);
pinMode(PRAWY, OUTPUT);
pinMode(HALOGEN1, OUTPUT);
pinMode(WSTECZNE, OUTPUT);
pinMode(HALOGEN2, OUTPUT);
pinMode(HALOGEN3, OUTPUT);
pinMode(HALOGEN4, OUTPUT);


}



// ################################################
//   POCZATEK LOOP
// ################################################

void loop() {

// ################################################
//   procedura odczytu danych z odbiornika
// ################################################

gaz_odczyt = pulseIn(GAZ, HIGH, 25000);
skret_odczyt = pulseIn(SKRET, HIGH, 25000);
aux1_odczyt = pulseIn(AUX, HIGH, 25000);



if(gaz_odczyt < 900 || gaz_odczyt > 2100 || skret_odczyt < 900 || skret_odczyt > 2100) {
  
  blad();
  
else {

if(wsteczne){
 noTone(BUZZER);

{
 
}


// ################################################
//   procedura dotycząca świateł przednich
// ################################################

if(digitalRead(REV_GAZ) == LOW) {
  
   if(gaz_odczyt < srodekPulse - 100) {
      przednie(1);
      wsteczne(1);
      awaryjne(1);
      tylne(1);
      gaz_stan = 1;
   } 
   
   if(gaz_odczyt > srodekPulse + 100) {
      przednie(1);
      wsteczne(0);
      tylne(1);
      gaz_stan = 1;
   } 
   
   if(gaz_odczyt <= srodekPulse + 100 && gaz_odczyt >= srodekPulse - 100 ) {
      przednie(1);
      wsteczne(0);
      tylne(1);
      gaz_stan = 0;
   } 
   

else {
  
   if(gaz_odczyt < srodekPulse - 100) {
      przednie(1);
      wsteczne(0);
      tylne(1);
      gaz_stan = 1;
   } 
   
   if(gaz_odczyt > srodekPulse + 100) {
      przednie(1);
      wsteczne(1);
      tylne(1);
      gaz_stan = 1;
   } 
   
   if(gaz_odczyt <= srodekPulse + 100 && gaz_odczyt >= srodekPulse - 100 ) {
      przednie(1);
      wsteczne(0);
      tylne(1);
      gaz_stan = 0;
   } 
   
}



// ################################################
//   procedura obsługi hamulca
// ################################################

if(gaz_stan != ostatni_gaz_stan) {

  if(ostatni_gaz_stan == 1 && gaz_stan == 0) {
      proces = 1;
      poprzedni_hamulec = millis();
  } 
  ostatni_gaz_stan = gaz_stan;


if(proces == 1) {
  
   if(millis() - poprzedni_hamulec <= dlugosc_hamulec) {
       analogWrite(TYLNE, 255);
   } else {
       analogWrite(TYLNE, 100);
       poprzedni_hamulec = millis();
       proces = 0;
   }
}  
  
  
// ################################################
//   procedura obsługi kierunkowskazów
// ################################################

if(awaryjne_blokada == false) {


   if(skret_odczyt < srodekPulse - neutrum) {
      migacz_lewy(1);
      migacz_prawy(0);
   } 
   
   if(skret_odczyt > srodekPulse + neutrum) {
      migacz_prawy(1);
      migacz_lewy(0);
   } 
  
   if((skret_odczyt >= srodekPulse - neutrum) && (skret_odczyt <= srodekPulse + neutrum)) {
      if(awaryjne_blokada == false) {
        migacz_lewy(0);
        migacz_prawy(0);
      }
   } 
  



}


// ################################################
//   procedura obsługi halogenów
// ################################################

if(aux_odczyt > srodekPulse + 50 neutrum || aux_odczyt < srodekPulse + 50 neutrum) {
  halogeny1(1);
else {
  halogeny1(0);
}

if(aux_odczyt > srodekPulse + 100 neutrum || aux_odczyt < srodekPulse + 100 neutrum) {
  halogeny2(1);
else {
  halogeny2(0);
}

if(aux_odczyt > srodekPulse - 50 neutrum || aux_odczyt < srodekPulse - 50 neutrum) {
  halogeny3(1);
else {
  halogeny3(0);
}

if(aux_odczyt > srodekPulse - 100 neutrum || aux_odczyt < srodekPulse - 100 neutrum) {
  halogeny4(1);
else {
  halogeny4(0);

}  

// ################################################
//               KONIEC LOOP
// ################################################





// ################################################
//               PROCEDURY
// ################################################





// ################################################
//   Kierunkowskaz lewy
// ################################################

void migacz_lewy(int komenda) {


  if (komenda == 1) {
    unsigned long aktualny = millis();
 
      if(aktualny - poprzedni_lewy >= przerwa_kierunkowskazy) {
        poprzedni_lewy = aktualny;   

        if (lewyStatus == 0)
          lewyStatus = 130;
        else
          lewyStatus = 0;
          analogWrite(LEWY,lewyStatus);
      }
  }

  if (komenda == 0) {
    analogWrite(LEWY, 0);
  }

}


// ################################################
//   Kierunkowskaz prawy
// ################################################

void migacz_prawy(int komenda) {

  if (komenda == 1) {
    unsigned long aktualny = millis();
     
      if(aktualny - poprzedni_prawy >= przerwa_kierunkowskazy) {
        poprzedni_prawy = aktualny;   
    
        if (prawyStatus == 0)
          prawyStatus = 130;
        else
          prawyStatus = 0;
          analogWrite(PRAWY, prawyStatus);
      }
  }

  if (komenda == 0) {
    analogWrite(PRAWY, 0);
  }

}


// ################################################
//   Tylne
// ################################################

void tylne(int komenda) {


  if(komenda == 1) { // pozycyjne
    analogWrite(TYLNE, 50);
  }
  
  if(komenda == 0) { // wyłączone
    analogWrite(TYLNE, 0);
  }  
  
}
  

// ################################################
//   Przednie
// ################################################


void przednie(int komenda) {
  
  if(komenda == 1) { // pozycyjne
    analogWrite(PRZEDNIE, 50);
  }

  
  
  if(komenda == 0) { // wyłączone
    analogWrite(PRZEDNIE, 0);
  }    
  
}  


// ################################################
//   Wsteczne
// ################################################

void wsteczne(int komenda) {
  
  if(komenda == 1) { // pozycyjne
    analogWrite(WSTECZNE, 255);
  }
  
  if(komenda == 0) { // wyłączone
    analogWrite(WSTECZNE, 0);
  }    
  
}    


// ################################################
//   Halogeny
// ################################################

void halogeny1(int komenda) {
  
  if(komenda == 1) { // pozycyjne
    analogWrite(HALOGEN, +50);
  }
  
  if(komenda == 0) { // wyłączone
    analogWrite(HALOGEN, 0);
  }    

  void halogeny2(int komenda) {
  
  if(komenda == 1) { // pozycyjne
    analogWrite(HALOGEN, +100);
  }
  
  if(komenda == 0) { // wyłączone
    analogWrite(HALOGEN, 0);
  }    

    void halogeny3(int komenda) {
  
  if(komenda == 1) { // pozycyjne
    analogWrite(HALOGEN, -50);
  }
  
  if(komenda == 0) { // wyłączone
    analogWrite(HALOGEN, 0);
  }    
void halogeny4(int komenda) {
  
  if(komenda == 1) { // pozycyjne
    analogWrite(HALOGEN, -100);
  }
  
  if(komenda == 0) { // wyłączone
    analogWrite(HALOGEN, 0);
  }    


// ################################################
//   Błąd odbiornika
// ################################################

   
void blad() {

    unsigned long aktualny_blad = millis();
     
      if(aktualny_blad - poprzedni_blad >= przerwa_blad) {
        poprzedni_blad = aktualny_blad;   
    
        if (bladStatus == 0)
          bladStatus = 255;
        else
          bladStatus = 0;
          analogWrite(LEWY, bladStatus);
          analogWrite(PRAWY, bladStatus);
          analogWrite(PRZEDNIE, bladStatus);
          analogWrite(TYLNE, bladStatus);
          analogWrite(WSTECZNE, bladStatus);
          analogWrite(HALOGEN, bladStatus);
      }
  
}


void loop() {
  // put your main code here, to run repeatedly:

}
Ps. a mi sie nie wkleilo tak jak tobie :scratch

Awatar użytkownika
Sławek
Site Admin
Posty: 14530
Rejestracja: 21 gru 2011, 22:12
Has thanked: 15 times
Been thanked: 21 times

Re: Forumowy Moduł Świateł

Post autor: Sławek »

Poprawiłem :)


Tu masz pierwszy błąd :

#define HALOGEN 11
#define HALOGEN 12
#define HALOGEN 13

Nnazwa HALOGEN się powtarza, trzeba zmienić zgodnie z tym co poniżej :

pinMode(HALOGEN2, OUTPUT);
pinMode(HALOGEN3, OUTPUT);
pinMode(HALOGEN4, OUTPUT);

#define - przypisanie stałej globalnej
HALOGEN - nazwa stałej
11 wartość

Czyli powinno być tak :

#define HALOGEN2 11
#define HALOGEN3 12
#define HALOGEN4 13


Kolejna kwestia, analogWrite,

if(komenda == 1) { // pozycyjne
analogWrite(HALOGEN, -100);
}

Definicja jest taka :
analogWrite(pin, wartosc z przedzialu 0-255);

Zatem wartość nie może przyjmować wartości ujemnej, 0 oznacza w tym przypadku wyłaczone, 255 włączone na 100%, wszystko co pomiędzy oznacza, że dioda będzie świecić słąbje lub mocniej. Tylko tu jedna uwaga, aby to działało proporcjonalnie, pin którym w ten sposób sterujesz musi być tzw. PWM, w innym przypadku wszystko co będzie w przedziale 0-127 będzie oznaczało wyłączony, a 128-255 włączony czyli będzie róznoważne z funkcją digitalWrite która wygląda następująco :
digitalWrite(nr_pin, LOW lub HIGH albo 0 lub 1)
czyli LOW = wyłączony, HIGH włączony, 0 = wyłączony, 1 = włączony - oczywiście może być odwrotnie, ale teraz nie będę ci mieszał :)

Poniżej masz opis pinów dla tego procka :
ATTiny84-ATTiny44-pinout[1].png
Piny oznaczone cyframi na brązowym tle (0-10) oznaczają nr pinów przeportowane pod Arduino C++ czyli to co jest w kodzie o góry w sekcji // WYJSCIA. Masz tez oznaczenie symbolem PWM, które z tych pinów można sterować proporcjonalnie, czyli PWM-em :)

Pozdr
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.

Awatar użytkownika
Sławek
Site Admin
Posty: 14530
Rejestracja: 21 gru 2011, 22:12
Has thanked: 15 times
Been thanked: 21 times

Re: Forumowy Moduł Świateł

Post autor: Sławek »

Aby było łatwiej programować, polecam zakup programatora USBASP https://botland.com.pl/programatory/201 ... olory.html
Mozna też wykorzystać arduino UNO aby zaprogramować attiny w razie wu :)

Pozdr

Awatar użytkownika
wajha1983
Kierowca
Posty: 4882
Rejestracja: 10 lis 2013, 16:21
Has thanked: 16 times
Been thanked: 10 times

Re: Forumowy Moduł Świateł

Post autor: wajha1983 »

Wielkie dzieki Slawku.
Narazie poczekam z robieniem zmian w projekcie, to bardziej skomplikowane niz myslalem, musze troche poczytac i zapoznac sie lepiej z programowaniem C++

Awatar użytkownika
Sławek
Site Admin
Posty: 14530
Rejestracja: 21 gru 2011, 22:12
Has thanked: 15 times
Been thanked: 21 times

Re: Forumowy Moduł Świateł

Post autor: Sławek »

Ok, to ja może na tym przykładzie opiszę i zrobię małe wprowadzenie które sporo wyjaśni :)

Kod w C++ składa się z trzech podstawowych części :

1. definicje zmiennych i stałych
2. procedura (void) setup - kod w tej procedurze jest wykonywany tylko raz przy starcie programu
2. pętla loop - kod w tej pętli wykonywany jest w pętli nieskończonej


// 1. definicje zmiennych i stalych

#define PIN 13
int czas = 1000;

// 2. procedura setup

void setup() {
  pinMode(PIN, OUTPUT);
}


// 3. petla loop

void loop() {
  digitalWrite(PIN, HIGH);
  delay(czas);
  digitalWrite(PIN, LOW);
  delay(czas);
}


No to zaczniemy od od zmiennych i stałych :

#define nazwa wartosc

Tą funkcją przypisuje się określonej nazwie stałą wartość która nie będzie ulegać zmianie w trakcie wykonywania programu, #define pozwala na oszczędność alokacji pamięci dla zmiennych, stąd powinno się ją wykorzystywać tak często jak to tylko możliwe.
Zasięg stałej jest pełny czyli dotyczy całego programu, jest to wartość globalna.

Teraz kolej na definicje zmiennych których wartości mogą ulegać zmianie w trakcie wykonywania programu.
Deklaracja zmiennych wygląda następująco :

typ_danych nazwa_zmiennej;

lub

typ_danych nazwa_zmiennej = wartość startowa zmiennej;


Podstawowe typy danych to :

byte - liczba z przedziału 0-255
int - liczba z przedziału -32 768 do 32 767
word - liczba z przedziału 0 - 65535
long - liczba z przedziału -2 147 483 648 do 2 147 483 647
float - liczba z przedziału -3.4028235E+38 do 3.4028235E+38
char - znak ASCII np. 'B'. Char przechowuje informację o kodzie, czyli liczba 66 to 'B'. Typ przechowuje wartości od -128 do 127
String - wartość tekstowa

Oprócz tego, zmienne mogą mieć rozszerzenie typu o unsigned, czyli liczby bez znaku :

unsigned char - znak ASCII zapisany jako liczba z przedziału 0 - 255
unsigned int - liczba z przedziału 0 - 65535
unsigned long - liczba z przedziału 0 - 4 294 967 295

Typów jest jeszcze kilka, ale te są najczęściej używane.

Zmienne mogą mieć zasięg globalny lub lokalny. Jeżeli zmienne są zadeklarowane na początku kodu przed pętlą loop lub setup, wtedy dostępnośc zmiennych jest globalna i w każdym miejscu kodu wartość zmiennej jest dostępna, natomiast jeżeli zmienna jest zadeklarowana wewnątrz procedury to jest dostępna tylko w obrębie tej procedury - im większy zasięg zmiennej tym więcej alokacji pamięci, warto o tym pamiętać.

No to teraz operatory :

Arytmetyczne

= a=0 - przypisuje wartość 0 do zmiennej a
+ a+b - suma
- a-b - różnica
* a*b - mnożenie
/ a/b - dzielenie
% a%b - modulo, czyli reszta z dzielenia

Logiczne :

== a==b - sprawdza czy oba wyrażenia są równe (nie mylić z operatorem = !)
!= a!=b - sprawdza czy wrażenia są różne
< a<b - sprawdza czy a jest mniejsze od b
> a>b - sprawdza czy a jest większe od b
>= a>=b - sprawdza czy a jest więsze lub równe b
<= a<=b - sprawdza czy a jest mniejsze lub równe b
&& a== && b==0 - sprawdza czy oba wyrażenia są prawdziwe czyli czy a jest równe 0 oraz b jest równe 0
|| a ==0|| b==0 - sprawdza czy jedno z wyrażeń jest prawdziwe czlu czy a jest równe 0 lub b jest równe 0
! !a - zmienia wartość logiczną wyrażenia na przeciwną czyli np. jeżeli a równało się 0 to będzie równe 1 i odwrotnie

Po każdej linii musi być ";" !!!

No i czas na instrukcje :

1. podstawowa instrukcja to if
if (jakis_warunek)

jakis kod;
}
I wyglądąc to może tak :
if(a == 0) {
b = 1;
}
Program sprawdza czy a = 0, jeżeli tak, to wartości zmiennej b przypisywana jest wartość 1.

A teraz podstawowy błąd :
if(a = 0) {
b = 1;
}
Niby wygląda bez zmian, ale błąd tkwi w pierwszej linii gdyż zamiast operatora porównania == zastosowano przypisanie czyli = (taka instrukcja warunkowa zwróci wartość false za każdym razem i nie bezie działać prawidłowo.

Kolejna postać instrukcji warunkowej if :
if(a == 0) {
b = 1;
else {
b=0;
}
Jeżeli a jest równe 0 to wartość b będzie miała wartość 1, natomiast w każdym innym przypadku (innym niż a = 0) wartość b będzie równa 0.

No i ostatnia postać instrukcji warunkowej if czyli wykorzystanie else if:
if(a == 0) {
b = 1;
else if (a==1) {
b=0;
else if(a==2) {
b=2;
}
Jeżeli a=0 to b=1, jeżeli nie, to jeżeli a=1 wtedy b=0, jeżeli nie, to jeżeli a=2 to b=2. Ta instrukcja wykonuje kolejne testowania wartości zmiennej a i wykonuje w zależności od wartości określone czynności, w tym przypadku przypisywania wartości zmiennej b.

A co w sytuacji, kiedy a nie przyjmie wartości aani 0, ani 1 i ani 2 ? wtedy zwróci wartość false, czyli nie wykona żadnej z instrukcji. Aby się przed tym zabezpieczyć, można dodać na końcu tak :
if(a == 0) {
b = 1;
else if (a==1) {
b=0;
else if(a==2) {
b=2;
else {
b=-1;
}
Czyli jeżeli a nie przyjmie jednej z wartości od 0 do 2, to wykona się ostatnia instrukcja, czyli b=-1.


Pętla for :

for(od, do, inkremntacja);
for(i=0; i<10, i++) {
b = b + 1;
}
A wiec po kolei, instrukcja wykonuje określoną ilość razy instrukcję z godnie z parametrami podanymi w w nawiasach, czyli do wartości 0 do wartości mniejszej od 10 (0-9 czyli 10 razy) i wartośc i będzie powiększana za każdym razem o 1. W wyniku tego, za każdym razem do wartości zmiennej b będzie dodawana wartość b +1 czyli jeżeli b =0 na starcie to w kolejnej iteracji b = b + 1 czyli 0 = 0 +1 a to sie równa 1, w kolejnej iteracji będzie powiększona o 1 itd.

W tej części tyle, w kolejnych częściach opisze kolejne funkcje i instrukcje :)

Pozdr

Awatar użytkownika
Hauler
Kierowca
Posty: 2012
Rejestracja: 26 kwie 2015, 11:38
Has thanked: 3 times
Been thanked: 13 times

Re: Forumowy Moduł Świateł

Post autor: Hauler »

Sławek jesteś wielki

Awatar użytkownika
griszaa
Złomiarz
Posty: 10987
Rejestracja: 22 sie 2012, 04:52
Been thanked: 2 times

Re: Forumowy Moduł Świateł

Post autor: griszaa »

Ze czlowiek sie nie chcial tego uczyc na studiach, tylko bral zaliczenia ... ale jak bym wiedzial ze kiedys mi sie to przyda do hobby , to inaczej bym so tego podchodzil

Ehh

Awatar użytkownika
Sławek
Site Admin
Posty: 14530
Rejestracja: 21 gru 2011, 22:12
Has thanked: 15 times
Been thanked: 21 times

Re: Forumowy Moduł Świateł

Post autor: Sławek »

Na naukę nigdy nie jest za późno, C++ z pozoru może wyglądać na trudny, to jest naprawdę proste :)

Pozdr

Awatar użytkownika
Hauler
Kierowca
Posty: 2012
Rejestracja: 26 kwie 2015, 11:38
Has thanked: 3 times
Been thanked: 13 times

Re: Forumowy Moduł Świateł

Post autor: Hauler »

A oto moja wersja kodu do modułu świateł

Kod gotowy do użycia na arduino
Dodana funkcja samokalibracji
Z dodatkowego kanału(przełącznik 3 pozycyjny lub potencjometr) sterujemy oświetleniem podstawowym tz. pierwsze przełączenie postojowe, drugie światła mijania, trzecie światła długie, po przełączeniu w drugą stronę włączamy/wyłączamy dodatkowe wyjście
Reszta funkcji bez zmian

:odlot
/*

  RCTRUCK.PL SN: #1001 v2.0 21/12/2016

  Oryginalne źródło :           http://rctruck.pl/forum/viewtopic.php?f=37&t=3457
  Oryginalny firmware :         by Slawek K. (unix@rctruck.pl)


  Schemat & Strona projectu :   http://rctruck.pl/forum/viewtopic.php?f=37&t=3457


*/

// WEJŚCIA
#define GAZ 14            //PIN 14
#define SKRET 15          //PIN 15
#define AUX 16            //PIN 16
#define REV_GAZ 17        //PIN 17


// WYJŚCIA
#define POSTOJOWE 2       //PIN 2
#define PRZEDNIE 3        //PIN 3
#define DLUGIE 4          //PIN 4
#define TYLNE 5           //PIN 5
#define LEWY 6            //PIN 6
#define PRAWY 7           //PIN 7
#define HALOGEN 8         //PIN 8
#define WSTECZNE 9        //PIN 9
#define BUZZER 10         //PIN 10

int lewyStatus = 0;
int prawyStatus = 0;
int awaryjneStatus = 0;
int bladStatus = 0;

unsigned long poprzedni_lewy = 0;
unsigned long poprzedni_prawy = 0;
unsigned long poprzedni_awaryjne = 0;
unsigned long poprzedni_hamulec = 0;
unsigned long poprzedni_blad = 0;
unsigned long aktualny_hamulec = 0;
unsigned long poprzedni_postoj = 0;

const long przerwa_kierunkowskazy = 500;
const int przerwa_blad = 500;
const long dlugosc_hamulec = 1500;

int maxPulse = 2000;
int minPulse = 900;
unsigned int srodekgaz = 0;
unsigned int srodekskret = 0;
unsigned int srodekaux = 0;
int neutrum = 150;

int kalibracja = 0;

int zmiana = 0;
int zmiana2 = 0;

int zaswiec_stop = 0;

unsigned long gaz_odczyt = 0;
unsigned long skret_odczyt = 0;
unsigned long aux_odczyt = 0;

int gaz_stan = 0;
int ostatni_gaz_stan = 0;

boolean awaryjne_blokada = false;
int proces = 0;



void setup() {

  pinMode(GAZ, INPUT);
  pinMode(SKRET, INPUT);
  pinMode(AUX, INPUT);
  pinMode(REV_GAZ, INPUT_PULLUP);



  pinMode(POSTOJOWE, OUTPUT);
  pinMode(PRZEDNIE, OUTPUT);
  pinMode(DLUGIE, OUTPUT);
  pinMode(TYLNE, OUTPUT);
  pinMode(LEWY, OUTPUT);
  pinMode(PRAWY, OUTPUT);
  pinMode(HALOGEN, OUTPUT);
  pinMode(WSTECZNE, OUTPUT);
  pinMode(BUZZER, OUTPUT);
  noTone(BUZZER);


}



// ################################################
//   POCZATEK LOOP
// ################################################

void loop() {

  // ################################################
  // procedura odczytu danych z odbiornika
  // ################################################

  gaz_odczyt = pulseIn(GAZ, HIGH, 25000);
  skret_odczyt = pulseIn(SKRET, HIGH, 25000);
  aux_odczyt = pulseIn(AUX, HIGH, 25000);




  if (gaz_odczyt < 800 || gaz_odczyt > 2100 || skret_odczyt < 800 || skret_odczyt > 2100) {

    blad();

  } else {



    // ################################################
    // Kalibracja pozycji neutralnej
    // ################################################


    if (kalibracja == 0) {
      srodekgaz = pulseIn(GAZ, HIGH, 25000);
      srodekskret = pulseIn(SKRET, HIGH, 25000);
      srodekaux = pulseIn(AUX, HIGH, 25000);
      kalibracja = 1;
    }



    if (awaryjne_blokada == false) {
      noTone(BUZZER);
    }


    // ################################################
    // procedura dotycząca świateł przednich
    // ################################################

    if (digitalRead(REV_GAZ) == LOW) {

      if (gaz_odczyt < srodekgaz - neutrum) {
        wsteczne(1);
        //awaryjne(1); // jęsli chcesz światła awaryjne przy cofaniu usuń dwa pierwsze ukosniki //
        awaryjne_blokada = true;
        gaz_stan = 1;
      }

      if (gaz_odczyt > srodekgaz + neutrum) {
        wsteczne(0);
        awaryjne_blokada = false;
        gaz_stan = 1;
      }

      if (gaz_odczyt <= srodekgaz + neutrum && gaz_odczyt >= srodekgaz - neutrum ) {
        wsteczne(0);
        awaryjne_blokada = false;
        gaz_stan = 0;
      }


    } else {

      if (gaz_odczyt < srodekgaz - neutrum) {
        wsteczne(0);
        awaryjne_blokada = false;
        gaz_stan = 1;
      }

      if (gaz_odczyt > srodekgaz + neutrum) {
        wsteczne(1);
        //awaryjne(1); // jęsli chcesz światła awaryjne przy cofaniu usuń dwa pierwsze ukosniki //
        awaryjne_blokada = false;
        gaz_stan = 1;
      }

      if (gaz_odczyt <= srodekgaz + neutrum && gaz_odczyt >= srodekgaz - neutrum ) {
        wsteczne(0);
        awaryjne_blokada = false;
        gaz_stan = 0;
      }

    }



    // ################################################
    // procedura obsługi hamulca
    // ################################################

    if (gaz_stan != ostatni_gaz_stan) {

      if (ostatni_gaz_stan == 1 && gaz_stan == 0) {
        proces = 1;
        poprzedni_hamulec = millis();
      }
      ostatni_gaz_stan = gaz_stan;
    }

    if (proces == 1) {

      if (millis() - poprzedni_hamulec <= dlugosc_hamulec) {
        analogWrite(TYLNE, 255);
      } else {
        analogWrite(TYLNE, poprzedni_postoj);
        poprzedni_hamulec = millis();
        proces = 0;
      }
    }


    // ################################################
    // procedura obsługi kierunkowskazów
    // ################################################

    if (awaryjne_blokada == false) {


      if (skret_odczyt < srodekskret - neutrum) {
        migacz_lewy(1);
        migacz_prawy(0);
      }

      if (skret_odczyt > srodekskret + neutrum) {
        migacz_prawy(1);
        migacz_lewy(0);
      }

      if ((skret_odczyt >= srodekskret - neutrum) && (skret_odczyt <= srodekskret + neutrum)) {
        if (awaryjne_blokada == false) {
          migacz_lewy(0);
          migacz_prawy(0);
        }
      }




    }

    // ################################################
    // procedura obsługi świateł
    // ################################################



    // Postojówki

    if (aux_odczyt > srodekaux + neutrum && zmiana == 0) {
      postoj(1);
      tylne(1);
      zmiana = 1;
    }

    if ((aux_odczyt >= srodekaux - neutrum) && (aux_odczyt <= srodekaux + neutrum) && (zmiana == 1)) {
      zmiana = 2;
    }



    // Mijania

    if (aux_odczyt > srodekaux + neutrum && zmiana == 2) {
      przednie(1);
      zmiana = 3;
    }

    if ((aux_odczyt >= srodekaux - neutrum) && (aux_odczyt <= srodekaux + neutrum) && (zmiana == 3)) {
      zmiana = 4;
    }



    // Długie

    if (aux_odczyt > srodekaux + neutrum && zmiana == 4) {
      dlugie(1);
      zmiana = 5;
    }

    if ((aux_odczyt >= srodekaux - neutrum) && (aux_odczyt <= srodekaux + neutrum) && (zmiana == 5)) {
      zmiana = 6;
    }



    // Wyłączenie

    if (aux_odczyt > srodekaux + neutrum && zmiana == 6) {
      postoj(0);
      przednie(0);
      dlugie(0);
      tylne(0);
      zmiana = 7;
    }

    if ((aux_odczyt >= srodekaux - neutrum) && (aux_odczyt <= srodekaux + neutrum) && (zmiana == 7)) {
      zmiana = 0;
    }

    // ################################################
    // procedura obsługi halogena
    // ################################################

    if (aux_odczyt < srodekaux - 200 && zmiana2 == 0) {
      halogeny(1);
      zmiana2 = 1;
    }

    if ((aux_odczyt >= srodekaux - neutrum) && (aux_odczyt <= srodekaux + neutrum) && (zmiana2 == 1)) {
      zmiana2 = 2;
    }


    if (aux_odczyt < srodekaux - 200 && zmiana2 == 2) {
      halogeny(0);
      zmiana2 = 3;
    }

    if ((aux_odczyt >= srodekaux - neutrum) && (aux_odczyt <= srodekaux + neutrum) && (zmiana2 == 3)) {
      zmiana2 = 0;
    }


  }

}

// ################################################
//               KONIEC LOOP
// ################################################





// ################################################
//               PROCEDURY
// ################################################





// ################################################
//   Kierunkowskaz lewy
// ################################################

void migacz_lewy(int komenda) {


  if (komenda == 1) {
    unsigned long aktualny = millis();

    if (aktualny - poprzedni_lewy >= przerwa_kierunkowskazy) {
      poprzedni_lewy = aktualny;

      if (lewyStatus == 0)
        lewyStatus = 130;
      else
        lewyStatus = 0;
      analogWrite(LEWY, lewyStatus);
    }
  }

  if (komenda == 0) {
    analogWrite(LEWY, 0);
  }

}


// ################################################
//   Kierunkowskaz prawy
// ################################################

void migacz_prawy(int komenda) {

  if (komenda == 1) {
    unsigned long aktualny = millis();

    if (aktualny - poprzedni_prawy >= przerwa_kierunkowskazy) {
      poprzedni_prawy = aktualny;

      if (prawyStatus == 0)
        prawyStatus = 130;
      else
        prawyStatus = 0;
      analogWrite(PRAWY, prawyStatus);
    }
  }

  if (komenda == 0) {
    analogWrite(PRAWY, 0);
  }

}


// ################################################
//   Awaryjne
// ################################################

void awaryjne(int komenda) {

  if (komenda == 1) {
    unsigned long aktualny_awaryjne = millis();

    if (aktualny_awaryjne - poprzedni_awaryjne >= przerwa_kierunkowskazy) {
      poprzedni_awaryjne = aktualny_awaryjne;

      if (awaryjneStatus == 0) {
        awaryjneStatus = 130;
        tone(BUZZER, 1800);

      } else {
        awaryjneStatus = 0;
        noTone(BUZZER);
      }

      analogWrite(LEWY, awaryjneStatus);
      analogWrite(PRAWY, awaryjneStatus);


    }
  }

  if (komenda == 0) {
    analogWrite(LEWY, 0);
    analogWrite(PRAWY, 0);
    noTone(BUZZER);
  }
}


// ################################################
//   Tylne
// ################################################

void tylne(int komenda) {


  if (komenda == 1) { // pozycyjne
    analogWrite(TYLNE, 50);
    poprzedni_postoj = 50;
  }

  if (komenda == 0) { // wyłączone
    analogWrite(TYLNE, 0);
    poprzedni_postoj = 0;
  }

}


// ################################################
//   Przednie
// ################################################


void postoj(int komenda) {

  if (komenda == 1) { // pozycyjne
    analogWrite(POSTOJOWE, 255);
  }


  if (komenda == 0) { // wyłączone
    analogWrite(POSTOJOWE, 0);
  }

}


void przednie(int komenda) {

  if (komenda == 1) { // mijania
    analogWrite(PRZEDNIE, 255);
  }


  if (komenda == 0) { // wyłączone
    analogWrite(PRZEDNIE, 0);
  }

}


void dlugie(int komenda) {

  if (komenda == 1) { // długie
    analogWrite(DLUGIE, 255);
  }


  if (komenda == 0) { // wyłączone
    analogWrite(DLUGIE, 0);
  }

}

// ################################################
//   Wsteczne
// ################################################

void wsteczne(int komenda) {

  if (komenda == 1) { // pozycyjne
    analogWrite(WSTECZNE, 255);

  }

  if (komenda == 0) { // wyłączone
    analogWrite(WSTECZNE, 0);
  }

}


// ################################################
//   Halogeny
// ################################################

void halogeny(int komenda) {

  if (komenda == 1) { // halogen
    analogWrite(HALOGEN, 255);
  }

  if (komenda == 0) { // wyłączone
    analogWrite(HALOGEN, 0);
  }

}



// ################################################
//   Błąd odbiornika
// ################################################


void blad() {

  unsigned long aktualny_blad = millis();

  if (aktualny_blad - poprzedni_blad >= przerwa_blad) {
    poprzedni_blad = aktualny_blad;

    if (bladStatus == 0)
      bladStatus = 255;
    else
      bladStatus = 0;
    analogWrite(LEWY, bladStatus);
    analogWrite(PRAWY, bladStatus);
    analogWrite(POSTOJOWE, bladStatus);
    analogWrite(PRZEDNIE, bladStatus);
    analogWrite(DLUGIE, bladStatus);
    analogWrite(TYLNE, bladStatus);
    analogWrite(WSTECZNE, bladStatus);
    analogWrite(HALOGEN, bladStatus);
  }

}

Awatar użytkownika
borek
Traktorzysta
Posty: 5212
Rejestracja: 22 sty 2012, 10:28
Has thanked: 16 times
Been thanked: 47 times

Re: Forumowy Moduł

Post autor: borek »

Bardzo ładnie, bo widziałem film jak to działa a fizycznie jesteś w stanie ogarnąć temat przedłużenia przewodów i zamontowania w Falkowie na placu na głównym skrzyżowaniu.Co ewentualnie potrzeba dokupić zrobić.

ODPOWIEDZ