Projekt zawiera schemat ideowy, zaprojektowaną płytkę oraz kod źródłowy
Może się komuś przyda i zechce sobie zrobić albo zmodyfikować soft
BOM :
U1 - ATTINY84
T1, T2 - BC337
R1 - 75R
R2, R4, R6, R7 - 47R
R3, R5 - 68R
R8, R9 - 10K
BUZZER - buzzer z generatorem 5V 12mm
Listwa kołkowa goldpin męski 2x7 - 1 szt.
Listwa kołkowa goldpin męski 1x3 - 5 szt.
Listwa kołkowa goldpin męski 1x2 - 3 szt.
Płytka PCB jednostronna o wymiarach 31.4 x 35.2mm
Schemat ideowy : Płytka : Miło mi będzie jak ktoś zechce sobie zrobić
Jakby ktoś chciał to mogę wytrawić płytki, proszę o info na PW
Soft napisany w C++ (Arduino) wiec można go również wgrać na arduino, tylko trzeba przeadresować piny
Jeżeli będziecie poprawiać soft to prosiłbym o zamieszczanie opisu i wstawianie kodu, fajnie jakby się soft dalej rozwijał jakby były pytania co do softu to chętnie odpowiem/wytłumaczę
Jak ktoś będzie potrzebował to opisze jak wgrać soft do Attiny poprzez Arduino IDE
Pozdr
Poniżej kod źródłowy :
/*
██████╗ ██████╗████████╗██████╗ ██╗ ██╗ ██████╗██╗ ██╗ ██████╗ ██╗
██╔══██╗██╔════╝╚══██╔══╝██╔══██╗██║ ██║██╔════╝██║ ██╔╝ ██╔══██╗██║
██████╔╝██║ ██║ ██████╔╝██║ ██║██║ █████╔╝ ██████╔╝██║
██╔══██╗██║ ██║ ██╔══██╗██║ ██║██║ ██╔═██╗ ██╔═══╝ ██║
██║ ██║╚██████╗ ██║ ██║ ██║╚██████╔╝╚██████╗██║ ██╗██╗██║ ███████╗
╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝╚═╝ ╚═╝╚═╝╚═╝ ╚══════╝
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 REV_GAZ 5
// WYJŚCIA
#define PRZEDNIE 2
#define TYLNE 3
#define LEWY 1
#define PRAWY 6
#define HALOGEN 0
#define WSTECZNE 10
#define BUZZER 4
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 = 1500;
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(REV_GAZ, INPUT_PULLUP);
pinMode(BUZZER, OUTPUT);
noTone(BUZZER);
pinMode(PRZEDNIE, OUTPUT);
pinMode(TYLNE, OUTPUT);
pinMode(LEWY, OUTPUT);
pinMode(PRAWY, OUTPUT);
pinMode(HALOGEN, OUTPUT);
pinMode(WSTECZNE, OUTPUT);
}
// ################################################
// 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 < 900 || gaz_odczyt > 2100 || skret_odczyt < 900 || skret_odczyt > 2100) {
blad();
} else {
if(awaryjne_blokada == false) {
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);
awaryjne_blokada = true;
gaz_stan = 1;
}
if(gaz_odczyt > srodekPulse + 100) {
przednie(1);
wsteczne(0);
awaryjne_blokada = false;
tylne(1);
gaz_stan = 1;
}
if(gaz_odczyt <= srodekPulse + 100 && gaz_odczyt >= srodekPulse - 100 ) {
przednie(1);
wsteczne(0);
awaryjne_blokada = false;
tylne(1);
gaz_stan = 0;
}
} else {
if(gaz_odczyt < srodekPulse - 100) {
przednie(1);
wsteczne(0);
awaryjne_blokada = false;
tylne(1);
gaz_stan = 1;
}
if(gaz_odczyt > srodekPulse + 100) {
przednie(1);
wsteczne(1);
awaryjne(1);
tylne(1);
awaryjne_blokada = true;
gaz_stan = 1;
}
if(gaz_odczyt <= srodekPulse + 100 && gaz_odczyt >= srodekPulse - 100 ) {
przednie(1);
wsteczne(0);
awaryjne_blokada = false;
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 + neutrum || aux_odczyt < srodekPulse - neutrum) {
halogeny(1);
przednie(2);
} else {
halogeny(0);
przednie(1);
}
}
}
// ################################################
// 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);
}
if(komenda == 0) { // wyłączone
analogWrite(TYLNE, 0);
}
}
// ################################################
// Przednie
// ################################################
void przednie(int komenda) {
if(komenda == 1) { // pozycyjne
analogWrite(PRZEDNIE, 50);
}
if(komenda == 2) { // pozycyjne
analogWrite(PRZEDNIE, 255);
}
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 halogeny(int komenda) {
if(komenda == 1) { // pozycyjne
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(PRZEDNIE, bladStatus);
analogWrite(TYLNE, bladStatus);
analogWrite(WSTECZNE, bladStatus);
analogWrite(HALOGEN, bladStatus);
}
}