Parking Sensors - PDC

DIY Park-Distance-Computer with custom MP3-Audio Output

Nov 20, 2020

•

1256 views

•

0 respects

music

cars

monitoring

Components and supplies

Arduino Nano R3

MP3 TF16 Player

JSN SR04

12V Amplifier diy

Tools and machines

Soldering iron (generic)

3D Printer (generic)

Apps and platforms

Arduino IDE

Project description

Code

Code for two Sensors with selfdiagnosting-phase in BootUp

arduino

The PDC starts a diagnosting phase bevor it´s ready to measure. If the Sensors seem to not working, the PDC puts itself into a faultmode. In this mode there will be allways a audio output "the System is not available" if you put the car in reverse. The audio output can be deactivated or activated by the switch.

1#include "Arduino.h"
2#include "SoftwareSerial.h"
3#include "DFRobotDFPlayerMini.h"
4
5SoftwareSerial  mySoftwareSerial(11, 10);                      //RX, TX MP3-Player
6DFRobotDFPlayerMini  Player;
7
8//+++++++Sensoren+++++++++
9int TriggerL = 9;                                             //TX  Left
10int TriggerR = 7;                                             //TX Right
11int  EchoL = 8;                                                //RX Left
12int EchoR  = 6;                                                //RX Right
13unsigned long  durationL = 0;
14unsigned long durationR = 0;
15
16//+++++++Diverses+++++++++++++
17int  Distanz, DisL, DisR, Zone, Reverse;
18int OVR = 2;                                                      //Taster  fr ueberschreiben
19int REV = 4;                                                      //Rckwrtsgang
20int  Override = 0;
21int Pointer = 1;
22int Unschaerfe = 0;
23int FehlerCount = 1;
24int  OVR_Fehler = 0;
25boolean Fehler = false;
26
27
28void setup() {
29  mySoftwareSerial.begin(9600);
30  Serial.begin(115200);
31  pinMode(OVR, INPUT);
32  pinMode(REV, INPUT);
33  pinMode(TriggerL, OUTPUT);
34  pinMode(TriggerR, OUTPUT);
35  pinMode(EchoL,  INPUT);
36  pinMode(EchoR, INPUT);
37  if (!Player.begin(mySoftwareSerial)) {                            //Kommunikation mit dem Soundmodul
38    Serial.println(F("Unable  to begin:"));
39    while(true);
40  }
41  Serial.println(F("DFPlayer Mini  online."));
42  Player.setTimeOut(500);                                           
43  Player.volume(25);                                                //Lautstrke  (0~30).
44  Player.EQ(DFPLAYER_EQ_BASS);
45  Player.outputDevice(DFPLAYER_DEVICE_SD);
46  BootUp();                                                         //System testen  etc. 
47}
48
49void loop() {
50  switch (Pointer) {
51    case 1:                                                     //OVR  Prfen (1,2)
52      if (digitalRead(OVR) == HIGH && Override == 0) {
53        static  unsigned long UnavTimer = millis();
54        Player.play(16);                                             //"TAS  unavailable"
55        if (millis() - UnavTimer > 2000) {
56          UnavTimer  = millis();
57        }
58        Override = 1;                                               //Taster  gedrckt, war vorher aktiv => System wird ausgeschaltet
59      }
60      else  if (digitalRead(OVR) ==  HIGH && Override == 1) {
61        static unsigned long  ActTimer = millis();
62        Player.play(11);                                             //"Beep"  (active)
63        if (millis() - ActTimer > 2000) {
64          ActTimer = millis();
65        }
66        Override = 0;                                               //Taster  gedrckt, war vorher ausgeschaltet => System wird eingeschaltet
67      }
68      switch  (Override) {
69        case 1:
70          Pointer = 1;                                              //Bleib  in der Schleife
71          delay(500);
72          break;
73        case 0:
74          Pointer = 2;                                              //Frage nach  REV
75          delay(500);
76          break;
77      }
78      Serial.println(Pointer);                                      //Ausgabe des nchsten Pointers
79    break;
80
81    case 2:                                                    //REV Prfen (1,3)
82      if (digitalRead(REV) == HIGH) {
83          Pointer = 3;                                              //Rckwrtsgang  aktiv => 3 (Messen)                                             
84          Unschaerfe  = 0;
85      }
86      else
87        Pointer = 1;                                                //Rckwrtsgang  nicht aktiv => 1
88      Serial.println(Pointer);                                      //Ausgabe  des nchsten Pointers
89    break;
90
91    case 3:                                                    //Messen,  Ausgeben (1)
92      Messen();
93      Auswertung();
94      Ausgabe();
95      Pointer  = 1;
96      Serial.println(Pointer);
97    break;
98
99    case 4:                                                   //Fehlerzustand
100        while (Fehler == true){
101          if(digitalRead(REV) == HIGH && FehlerCount  == 1){
102            delay(500);
103            Player.play(16);                              //"TAS  unavailable"
104            FehlerCount = 0;
105            delay(1000);
106          }
107          if (digitalRead(REV) == LOW && FehlerCount == 0){
108             FehlerCount  = 1;
109             delay(500);
110          }
111          if (digitalRead(OVR)  == HIGH && OVR_Fehler == 0){ //"TAS unavailabl                                                                 e"  Ansage aus
112            FehlerCount = 2;
113            OVR_Fehler = 1;
114            Player.play(11);                                                                                                          //"BeepBeep"  fr Aus
115            delay(500);
116            Player.play(11);
117            Serial.println("Ansage  aus");
118            delay(500);
119          }
120          if (digitalRead(OVR)  == HIGH && OVR_Fehler == 1){ //"TAS unavailabl                                                                 e"  Ansage an
121            FehlerCount = 1;
122            OVR_Fehler = 0;
123            Player.play(11);                                // "Beep" fr An 
124            Serial.println("Ansage  an");
125            delay(500);
126          }
127        }
128    break;
129  }
130}
131
132//------------------------------------------------------------------------
133
134void  BootUp(){
135
136  
137  Messen();
138  if (DisR && DisL >= 10){
139     Fehler  = false;
140     delay(1000);
141     Player.play(14);                                          //"TAS-Test  Completed"
142     delay(4500);
143  }
144  else {
145     Fehler = true;
146     Serial.print("Unable  to begin: Fehler ");
147     Serial.println(Fehler);
148     Player.play(15);                                          //"Test  Fail"
149     delay(2500);
150     Pointer = 4;
151  }
152}
153
154void Messen()  {
155  digitalWrite(TriggerL, HIGH);                               //Links messen
156  delayMicroseconds(20);
157  digitalWrite(TriggerL, LOW);
158  durationL = pulseIn(EchoL,  HIGH);
159  DisL = durationL * 0.034 / 2;
160  Serial.print(DisL);
161
162  digitalWrite(TriggerR,  HIGH);                               //Rechts messen
163  delayMicroseconds(20);
164  digitalWrite(TriggerR, LOW);
165  durationR = pulseIn(EchoR, HIGH);
166  DisR  = durationR * 0.034 / 2;
167  Serial.print("\	");
168  Serial.println(DisR);
169
170  if (DisL < DisR) {
171    Distanz = DisL;                                           //Vergleichen                                          und das geringere Ergebniss ausgeben
172  }
173  else if (DisL == DisR) {
174    Distanz = DisL;                                           //DisL  bekommt                                                         immer die Priorität!
175  } 
176  else {
177    Distanz = DisR;
178  }
179  Serial.print("\	");Serial.print("\	");Serial.print("\	");
180  Serial.println(Distanz);
181}
182                                                                                 //==========================================//
183void  Auswertung() {                                                                                      //  Unschaerfe ist eine Variable             //
184  if (Distanz >= 20 && Distanz <=  30) {               //0,2 - 0,3 -> 20         // die Wahrschienlichkeit einer Kritischen  //
185    Zone = 1;                                                                   //  Distanz. (unter 20cm)                    //
186    Unschaerfe = 1;                                                             //==========================================//
187  }
188  if (Distanz >= 31 && Distanz <= 40) {               //0,3 - 0,4 -> 30
189    Zone = 2;
190    Unschaerfe = 1;
191  }
192  if (Distanz >= 41 && Distanz <=  50) {               //0,4 - 0,5 -> 40
193    Zone = 3;
194    Unschaerfe = 1;
195  }
196  if (Distanz >= 51 && Distanz <= 60) {               //0,5 - 0,6 -> 50
197    Zone = 4;
198    Unschaerfe = 1;
199  }
200  if (Distanz >= 61 && Distanz <=  80) {               //0,6 - 0,8 -> 60
201    Zone = 5;
202    Unschaerfe = 0;
203  }
204  if (Distanz >= 81 && Distanz <= 100) {              //0,8 - 1m  -> 80
205    Zone = 6;
206    Unschaerfe = 0;
207  }
208  if (Distanz >= 101 && Distanz <=  140) {             //1 - 1,4m  -> 100
209    Zone = 7;
210    Unschaerfe = 0;
211  }
212  if (Distanz >= 141 && Distanz <= 200){              //1,4 - 2m  -> 150
213    Zone = 8;
214    Unschaerfe = 0;
215  }
216  if (Distanz >= 201 && Distanz <=  250){              //2 - 2,5m  -> 200
217    Zone = 9;
218    Unschaerfe = 0;
219  }
220  if (Distanz >= 250 && Distanz <= 400){               //2,5 - 4m  -> 250
221    Zone = 10;
222    Unschaerfe = 0;
223  }
224  if (Distanz >= 401 && Unschaerfe  == 1){             //<0,2  -> terrain
225    Zone = 11;
226  }
227  if (Distanz  >= 401 && Unschaerfe == 0){
228    Zone = 0;
229  }  
230  Serial.print("\	");Serial.print("\	");Serial.print("Zone:  ");
231  Serial.println(Zone);
232}
233
234
235void Ausgabe() {
236  switch (Zone)  {
237    case 0:
238       Player.play(19);                               //-Stille-
239    break;
240    
241    case 1:
242      Player.play(13);                                //"Terrain"
243      delay(500);
244    break;
245
246    case 2:
247      Player.play(2);                                //"30"
248      delay(500);
249      Player.play(12);                                 //"retard"
250      delay(500);
251    break;
252
253    case 3:
254      Player.play(3);                                //"40"
255      delay(500);
256      Player.play(12);                                 //"retard"
257      delay(500);
258    break;
259
260    case 4:
261      Player.play(4);                                //"50"
262      delay(500);
263      Player.play(12);                                 //"retard"
264      delay(500);       
265    break;
266
267    case 5:
268      Player.play(5);                                //"60"
269      delay(500);
270    break;
271
272    case 6:
273      Player.play(6);                                //"80"
274      delay(500);
275    break;
276
277    case 7:
278      Player.play(7);                                //"100"
279      delay(500);
280    break;
281
282    case 8:
283      Player.play(8);                                 //"150"
284      delay(500);
285    break;
286
287    case 9:
288      Player.play(9);                                 //"200"
289      delay(500);
290    break;
291
292    case 10:
293      Player.play(10);                                 //"250"
294      delay(500);
295    break;  
296     
297    case 11:
298      Player.play(13);                                 //"Terrain, Terrain"
299      delay(500);
300    break;
301  }
302}
303

#include "Arduino.h"
#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"

SoftwareSerial  mySoftwareSerial(11, 10);                      //RX, TX MP3-Player
DFRobotDFPlayerMini  Player;

//+++++++Sensoren+++++++++
int TriggerL = 9;                                             //TX  Left
int TriggerR = 7;                                             //TX Right
int  EchoL = 8;                                                //RX Left
int EchoR  = 6;                                                //RX Right
unsigned long  durationL = 0;
unsigned long durationR = 0;

//+++++++Diverses+++++++++++++
int  Distanz, DisL, DisR, Zone, Reverse;
int OVR = 2;                                                      //Taster  fr ueberschreiben
int REV = 4;                                                      //Rckwrtsgang
int  Override = 0;
int Pointer = 1;
int Unschaerfe = 0;
int FehlerCount = 1;
int  OVR_Fehler = 0;
boolean Fehler = false;


void setup() {
  mySoftwareSerial.begin(9600);
  Serial.begin(115200);
  pinMode(OVR, INPUT);
  pinMode(REV, INPUT);
  pinMode(TriggerL, OUTPUT);
  pinMode(TriggerR, OUTPUT);
  pinMode(EchoL,  INPUT);
  pinMode(EchoR, INPUT);
  if (!Player.begin(mySoftwareSerial)) {                            //Kommunikation mit dem Soundmodul
    Serial.println(F("Unable  to begin:"));
    while(true);
  }
  Serial.println(F("DFPlayer Mini  online."));
  Player.setTimeOut(500);                                           
  Player.volume(25);                                                //Lautstrke  (0~30).
  Player.EQ(DFPLAYER_EQ_BASS);
  Player.outputDevice(DFPLAYER_DEVICE_SD);
  BootUp();                                                         //System testen  etc. 
}

void loop() {
  switch (Pointer) {
    case 1:                                                     //OVR  Prfen (1,2)
      if (digitalRead(OVR) == HIGH && Override == 0) {
        static  unsigned long UnavTimer = millis();
        Player.play(16);                                             //"TAS  unavailable"
        if (millis() - UnavTimer > 2000) {
          UnavTimer  = millis();
        }
        Override = 1;                                               //Taster  gedrckt, war vorher aktiv => System wird ausgeschaltet
      }
      else  if (digitalRead(OVR) ==  HIGH && Override == 1) {
        static unsigned long  ActTimer = millis();
        Player.play(11);                                             //"Beep"  (active)
        if (millis() - ActTimer > 2000) {
          ActTimer = millis();
        }
        Override = 0;                                               //Taster  gedrckt, war vorher ausgeschaltet => System wird eingeschaltet
      }
      switch  (Override) {
        case 1:
          Pointer = 1;                                              //Bleib  in der Schleife
          delay(500);
          break;
        case 0:
          Pointer = 2;                                              //Frage nach  REV
          delay(500);
          break;
      }
      Serial.println(Pointer);                                      //Ausgabe des nchsten Pointers
    break;

    case 2:                                                    //REV Prfen (1,3)
      if (digitalRead(REV) == HIGH) {
          Pointer = 3;                                              //Rckwrtsgang  aktiv => 3 (Messen)                                             
          Unschaerfe  = 0;
      }
      else
        Pointer = 1;                                                //Rckwrtsgang  nicht aktiv => 1
      Serial.println(Pointer);                                      //Ausgabe  des nchsten Pointers
    break;

    case 3:                                                    //Messen,  Ausgeben (1)
      Messen();
      Auswertung();
      Ausgabe();
      Pointer  = 1;
      Serial.println(Pointer);
    break;

    case 4:                                                   //Fehlerzustand
        while (Fehler == true){
          if(digitalRead(REV) == HIGH && FehlerCount  == 1){
            delay(500);
            Player.play(16);                              //"TAS  unavailable"
            FehlerCount = 0;
            delay(1000);
          }
          if (digitalRead(REV) == LOW && FehlerCount == 0){
             FehlerCount  = 1;
             delay(500);
          }
          if (digitalRead(OVR)  == HIGH && OVR_Fehler == 0){ //"TAS unavailabl                                                                 e"  Ansage aus
            FehlerCount = 2;
            OVR_Fehler = 1;
            Player.play(11);                                                                                                          //"BeepBeep"  fr Aus
            delay(500);
            Player.play(11);
            Serial.println("Ansage  aus");
            delay(500);
          }
          if (digitalRead(OVR)  == HIGH && OVR_Fehler == 1){ //"TAS unavailabl                                                                 e"  Ansage an
            FehlerCount = 1;
            OVR_Fehler = 0;
            Player.play(11);                                // "Beep" fr An 
            Serial.println("Ansage  an");
            delay(500);
          }
        }
    break;
  }
}

//------------------------------------------------------------------------

void  BootUp(){

  
  Messen();
  if (DisR && DisL >= 10){
     Fehler  = false;
     delay(1000);
     Player.play(14);                                          //"TAS-Test  Completed"
     delay(4500);
  }
  else {
     Fehler = true;
     Serial.print("Unable  to begin: Fehler ");
     Serial.println(Fehler);
     Player.play(15);                                          //"Test  Fail"
     delay(2500);
     Pointer = 4;
  }
}

void Messen()  {
  digitalWrite(TriggerL, HIGH);                               //Links messen
  delayMicroseconds(20);
  digitalWrite(TriggerL, LOW);
  durationL = pulseIn(EchoL,  HIGH);
  DisL = durationL * 0.034 / 2;
  Serial.print(DisL);

  digitalWrite(TriggerR,  HIGH);                               //Rechts messen
  delayMicroseconds(20);
  digitalWrite(TriggerR, LOW);
  durationR = pulseIn(EchoR, HIGH);
  DisR  = durationR * 0.034 / 2;
  Serial.print("\	");
  Serial.println(DisR);

  if (DisL < DisR) {
    Distanz = DisL;                                           //Vergleichen                                          und das geringere Ergebniss ausgeben
  }
  else if (DisL == DisR) {
    Distanz = DisL;                                           //DisL  bekommt                                                         immer die Priorität!
  } 
  else {
    Distanz = DisR;
  }
  Serial.print("\	");Serial.print("\	");Serial.print("\	");
  Serial.println(Distanz);
}
                                                                                 //==========================================//
void  Auswertung() {                                                                                      //  Unschaerfe ist eine Variable             //
  if (Distanz >= 20 && Distanz <=  30) {               //0,2 - 0,3 -> 20         // die Wahrschienlichkeit einer Kritischen  //
    Zone = 1;                                                                   //  Distanz. (unter 20cm)                    //
    Unschaerfe = 1;                                                             //==========================================//
  }
  if (Distanz >= 31 && Distanz <= 40) {               //0,3 - 0,4 -> 30
    Zone = 2;
    Unschaerfe = 1;
  }
  if (Distanz >= 41 && Distanz <=  50) {               //0,4 - 0,5 -> 40
    Zone = 3;
    Unschaerfe = 1;
  }
  if (Distanz >= 51 && Distanz <= 60) {               //0,5 - 0,6 -> 50
    Zone = 4;
    Unschaerfe = 1;
  }
  if (Distanz >= 61 && Distanz <=  80) {               //0,6 - 0,8 -> 60
    Zone = 5;
    Unschaerfe = 0;
  }
  if (Distanz >= 81 && Distanz <= 100) {              //0,8 - 1m  -> 80
    Zone = 6;
    Unschaerfe = 0;
  }
  if (Distanz >= 101 && Distanz <=  140) {             //1 - 1,4m  -> 100
    Zone = 7;
    Unschaerfe = 0;
  }
  if (Distanz >= 141 && Distanz <= 200){              //1,4 - 2m  -> 150
    Zone = 8;
    Unschaerfe = 0;
  }
  if (Distanz >= 201 && Distanz <=  250){              //2 - 2,5m  -> 200
    Zone = 9;
    Unschaerfe = 0;
  }
  if (Distanz >= 250 && Distanz <= 400){               //2,5 - 4m  -> 250
    Zone = 10;
    Unschaerfe = 0;
  }
  if (Distanz >= 401 && Unschaerfe  == 1){             //<0,2  -> terrain
    Zone = 11;
  }
  if (Distanz  >= 401 && Unschaerfe == 0){
    Zone = 0;
  }  
  Serial.print("\	");Serial.print("\	");Serial.print("Zone:  ");
  Serial.println(Zone);
}


void Ausgabe() {
  switch (Zone)  {
    case 0:
       Player.play(19);                               //-Stille-
    break;
    
    case 1:
      Player.play(13);                                //"Terrain"
      delay(500);
    break;

    case 2:
      Player.play(2);                                //"30"
      delay(500);
      Player.play(12);                                 //"retard"
      delay(500);
    break;

    case 3:
      Player.play(3);                                //"40"
      delay(500);
      Player.play(12);                                 //"retard"
      delay(500);
    break;

    case 4:
      Player.play(4);                                //"50"
      delay(500);
      Player.play(12);                                 //"retard"
      delay(500);       
    break;

    case 5:
      Player.play(5);                                //"60"
      delay(500);
    break;

    case 6:
      Player.play(6);                                //"80"
      delay(500);
    break;

    case 7:
      Player.play(7);                                //"100"
      delay(500);
    break;

    case 8:
      Player.play(8);                                 //"150"
      delay(500);
    break;

    case 9:
      Player.play(9);                                 //"200"
      delay(500);
    break;

    case 10:
      Player.play(10);                                 //"250"
      delay(500);
    break;  
     
    case 11:
      Player.play(13);                                 //"Terrain, Terrain"
      delay(500);
    break;
  }
}

Code for two Sensors with selfdiagnosting-phase in BootUp

arduino

1#include "Arduino.h"
2#include "SoftwareSerial.h"
3#include "DFRobotDFPlayerMini.h"
4
5SoftwareSerial
6  mySoftwareSerial(11, 10);                      //RX, TX MP3-Player
7DFRobotDFPlayerMini
8  Player;
9
10//+++++++Sensoren+++++++++
11int TriggerL = 9;                                             //TX
12  Left
13int TriggerR = 7;                                             //TX Right
14int
15  EchoL = 8;                                                //RX Left
16int EchoR
17  = 6;                                                //RX Right
18unsigned long
19  durationL = 0;
20unsigned long durationR = 0;
21
22//+++++++Diverses+++++++++++++
23int
24  Distanz, DisL, DisR, Zone, Reverse;
25int OVR = 2;                                                      //Taster
26  fr ueberschreiben
27int REV = 4;                                                      //Rckwrtsgang
28int
29  Override = 0;
30int Pointer = 1;
31int Unschaerfe = 0;
32int FehlerCount = 1;
33int
34  OVR_Fehler = 0;
35boolean Fehler = false;
36
37
38void setup() {
39  mySoftwareSerial.begin(9600);
40
41  Serial.begin(115200);
42  pinMode(OVR, INPUT);
43  pinMode(REV, INPUT);
44
45  pinMode(TriggerL, OUTPUT);
46  pinMode(TriggerR, OUTPUT);
47  pinMode(EchoL,
48  INPUT);
49  pinMode(EchoR, INPUT);
50  if (!Player.begin(mySoftwareSerial)) {
51                            //Kommunikation mit dem Soundmodul
52    Serial.println(F("Unable
53  to begin:"));
54    while(true);
55  }
56  Serial.println(F("DFPlayer Mini
57  online."));
58  Player.setTimeOut(500);                                           
59
60  Player.volume(25);                                                //Lautstrke
61  (0~30).
62  Player.EQ(DFPLAYER_EQ_BASS);
63  Player.outputDevice(DFPLAYER_DEVICE_SD);
64
65  BootUp();                                                         //System testen
66  etc. 
67}
68
69void loop() {
70  switch (Pointer) {
71    case 1:                                                     //OVR
72  Prfen (1,2)
73      if (digitalRead(OVR) == HIGH && Override == 0) {
74        static
75  unsigned long UnavTimer = millis();
76        Player.play(16);                                             //"TAS
77  unavailable"
78        if (millis() - UnavTimer > 2000) {
79          UnavTimer
80  = millis();
81        }
82        Override = 1;                                               //Taster
83  gedrckt, war vorher aktiv => System wird ausgeschaltet
84      }
85      else
86  if (digitalRead(OVR) ==  HIGH && Override == 1) {
87        static unsigned long
88  ActTimer = millis();
89        Player.play(11);                                             //"Beep"
90  (active)
91        if (millis() - ActTimer > 2000) {
92          ActTimer = millis();
93
94        }
95        Override = 0;                                               //Taster
96  gedrckt, war vorher ausgeschaltet => System wird eingeschaltet
97      }
98      switch
99  (Override) {
100        case 1:
101          Pointer = 1;                                              //Bleib
102  in der Schleife
103          delay(500);
104          break;
105        case 0:
106
107          Pointer = 2;                                              //Frage nach
108  REV
109          delay(500);
110          break;
111      }
112      Serial.println(Pointer);
113                                      //Ausgabe des nchsten Pointers
114    break;
115
116
117    case 2:                                                    //REV Prfen (1,3)
118
119      if (digitalRead(REV) == HIGH) {
120          Pointer = 3;                                              //Rckwrtsgang
121  aktiv => 3 (Messen)                                             
122          Unschaerfe
123  = 0;
124      }
125      else
126        Pointer = 1;                                                //Rckwrtsgang
127  nicht aktiv => 1
128      Serial.println(Pointer);                                      //Ausgabe
129  des nchsten Pointers
130    break;
131
132    case 3:                                                    //Messen,
133  Ausgeben (1)
134      Messen();
135      Auswertung();
136      Ausgabe();
137      Pointer
138  = 1;
139      Serial.println(Pointer);
140    break;
141
142    case 4:                                                   //Fehlerzustand
143
144        while (Fehler == true){
145          if(digitalRead(REV) == HIGH && FehlerCount
146  == 1){
147            delay(500);
148            Player.play(16);                              //"TAS
149  unavailable"
150            FehlerCount = 0;
151            delay(1000);
152          }
153
154          if (digitalRead(REV) == LOW && FehlerCount == 0){
155             FehlerCount
156  = 1;
157             delay(500);
158          }
159          if (digitalRead(OVR)
160  == HIGH && OVR_Fehler == 0){ //"TAS unavailabl                                                                 e"
161  Ansage aus
162            FehlerCount = 2;
163            OVR_Fehler = 1;
164            Player.play(11);
165                                                                                                          //"BeepBeep"
166  fr Aus
167            delay(500);
168            Player.play(11);
169            Serial.println("Ansage
170  aus");
171            delay(500);
172          }
173          if (digitalRead(OVR)
174  == HIGH && OVR_Fehler == 1){ //"TAS unavailabl                                                                 e"
175  Ansage an
176            FehlerCount = 1;
177            OVR_Fehler = 0;
178            Player.play(11);
179                                // "Beep" fr An 
180            Serial.println("Ansage
181  an");
182            delay(500);
183          }
184        }
185    break;
186
187  }
188}
189
190//------------------------------------------------------------------------
191
192void
193  BootUp(){
194
195  
196  Messen();
197  if (DisR && DisL >= 10){
198     Fehler
199  = false;
200     delay(1000);
201     Player.play(14);                                          //"TAS-Test
202  Completed"
203     delay(4500);
204  }
205  else {
206     Fehler = true;
207     Serial.print("Unable
208  to begin: Fehler ");
209     Serial.println(Fehler);
210     Player.play(15);                                          //"Test
211  Fail"
212     delay(2500);
213     Pointer = 4;
214  }
215}
216
217void Messen()
218  {
219  digitalWrite(TriggerL, HIGH);                               //Links messen
220
221  delayMicroseconds(20);
222  digitalWrite(TriggerL, LOW);
223  durationL = pulseIn(EchoL,
224  HIGH);
225  DisL = durationL * 0.034 / 2;
226  Serial.print(DisL);
227
228  digitalWrite(TriggerR,
229  HIGH);                               //Rechts messen
230  delayMicroseconds(20);
231
232  digitalWrite(TriggerR, LOW);
233  durationR = pulseIn(EchoR, HIGH);
234  DisR
235  = durationR * 0.034 / 2;
236  Serial.print("\	");
237  Serial.println(DisR);
238
239
240  if (DisL < DisR) {
241    Distanz = DisL;                                           //Vergleichen
242                                          und das geringere Ergebniss ausgeben
243
244  }
245  else if (DisL == DisR) {
246    Distanz = DisL;                                           //DisL
247  bekommt                                                         immer die Priorität!
248
249  } 
250  else {
251    Distanz = DisR;
252  }
253  Serial.print("\	");Serial.print("\	");Serial.print("\	");
254
255  Serial.println(Distanz);
256}
257                                                                                 //==========================================//
258void
259  Auswertung() {                                                                                      //
260  Unschaerfe ist eine Variable             //
261  if (Distanz >= 20 && Distanz <=
262  30) {               //0,2 - 0,3 -> 20         // die Wahrschienlichkeit einer Kritischen
263  //
264    Zone = 1;                                                                   //
265  Distanz. (unter 20cm)                    //
266    Unschaerfe = 1;                                                             //==========================================//
267
268  }
269  if (Distanz >= 31 && Distanz <= 40) {               //0,3 - 0,4 -> 30
270
271    Zone = 2;
272    Unschaerfe = 1;
273  }
274  if (Distanz >= 41 && Distanz <=
275  50) {               //0,4 - 0,5 -> 40
276    Zone = 3;
277    Unschaerfe = 1;
278
279  }
280  if (Distanz >= 51 && Distanz <= 60) {               //0,5 - 0,6 -> 50
281
282    Zone = 4;
283    Unschaerfe = 1;
284  }
285  if (Distanz >= 61 && Distanz <=
286  80) {               //0,6 - 0,8 -> 60
287    Zone = 5;
288    Unschaerfe = 0;
289
290  }
291  if (Distanz >= 81 && Distanz <= 100) {              //0,8 - 1m  -> 80
292
293    Zone = 6;
294    Unschaerfe = 0;
295  }
296  if (Distanz >= 101 && Distanz <=
297  140) {             //1 - 1,4m  -> 100
298    Zone = 7;
299    Unschaerfe = 0;
300
301  }
302  if (Distanz >= 141 && Distanz <= 200){              //1,4 - 2m  -> 150
303
304    Zone = 8;
305    Unschaerfe = 0;
306  }
307  if (Distanz >= 201 && Distanz <=
308  250){              //2 - 2,5m  -> 200
309    Zone = 9;
310    Unschaerfe = 0;
311
312  }
313  if (Distanz >= 250 && Distanz <= 400){               //2,5 - 4m  -> 250
314
315    Zone = 10;
316    Unschaerfe = 0;
317  }
318  if (Distanz >= 401 && Unschaerfe
319  == 1){             //<0,2  -> terrain
320    Zone = 11;
321  }
322  if (Distanz
323  >= 401 && Unschaerfe == 0){
324    Zone = 0;
325  }  
326  Serial.print("\	");Serial.print("\	");Serial.print("Zone:
327  ");
328  Serial.println(Zone);
329}
330
331
332void Ausgabe() {
333  switch (Zone)
334  {
335    case 0:
336       Player.play(19);                               //-Stille-
337
338    break;
339    
340    case 1:
341      Player.play(13);                                //"Terrain"
342
343      delay(500);
344    break;
345
346    case 2:
347      Player.play(2);                                //"30"
348
349      delay(500);
350      Player.play(12);                                 //"retard"
351
352      delay(500);
353    break;
354
355    case 3:
356      Player.play(3);                                //"40"
357
358      delay(500);
359      Player.play(12);                                 //"retard"
360
361      delay(500);
362    break;
363
364    case 4:
365      Player.play(4);                                //"50"
366
367      delay(500);
368      Player.play(12);                                 //"retard"
369
370      delay(500);       
371    break;
372
373    case 5:
374      Player.play(5);
375                                //"60"
376      delay(500);
377    break;
378
379
380    case 6:
381      Player.play(6);                                //"80"
382
383      delay(500);
384    break;
385
386    case 7:
387      Player.play(7);                                //"100"
388
389      delay(500);
390    break;
391
392    case 8:
393      Player.play(8);                                 //"150"
394
395      delay(500);
396    break;
397
398    case 9:
399      Player.play(9);                                 //"200"
400
401      delay(500);
402    break;
403
404    case 10:
405      Player.play(10);                                 //"250"
406
407      delay(500);
408    break;  
409     
410    case 11:
411      Player.play(13);
412                                 //"Terrain, Terrain"
413      delay(500);
414
415    break;
416  }
417}
418

#include "Arduino.h"
#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"

SoftwareSerial
  mySoftwareSerial(11, 10);                      //RX, TX MP3-Player
DFRobotDFPlayerMini
  Player;

//+++++++Sensoren+++++++++
int TriggerL = 9;                                             //TX
  Left
int TriggerR = 7;                                             //TX Right
int
  EchoL = 8;                                                //RX Left
int EchoR
  = 6;                                                //RX Right
unsigned long
  durationL = 0;
unsigned long durationR = 0;

//+++++++Diverses+++++++++++++
int
  Distanz, DisL, DisR, Zone, Reverse;
int OVR = 2;                                                      //Taster
  fr ueberschreiben
int REV = 4;                                                      //Rckwrtsgang
int
  Override = 0;
int Pointer = 1;
int Unschaerfe = 0;
int FehlerCount = 1;
int
  OVR_Fehler = 0;
boolean Fehler = false;


void setup() {
  mySoftwareSerial.begin(9600);

  Serial.begin(115200);
  pinMode(OVR, INPUT);
  pinMode(REV, INPUT);

  pinMode(TriggerL, OUTPUT);
  pinMode(TriggerR, OUTPUT);
  pinMode(EchoL,
  INPUT);
  pinMode(EchoR, INPUT);
  if (!Player.begin(mySoftwareSerial)) {
                            //Kommunikation mit dem Soundmodul
    Serial.println(F("Unable
  to begin:"));
    while(true);
  }
  Serial.println(F("DFPlayer Mini
  online."));
  Player.setTimeOut(500);                                           

  Player.volume(25);                                                //Lautstrke
  (0~30).
  Player.EQ(DFPLAYER_EQ_BASS);
  Player.outputDevice(DFPLAYER_DEVICE_SD);

  BootUp();                                                         //System testen
  etc. 
}

void loop() {
  switch (Pointer) {
    case 1:                                                     //OVR
  Prfen (1,2)
      if (digitalRead(OVR) == HIGH && Override == 0) {
        static
  unsigned long UnavTimer = millis();
        Player.play(16);                                             //"TAS
  unavailable"
        if (millis() - UnavTimer > 2000) {
          UnavTimer
  = millis();
        }
        Override = 1;                                               //Taster
  gedrckt, war vorher aktiv => System wird ausgeschaltet
      }
      else
  if (digitalRead(OVR) ==  HIGH && Override == 1) {
        static unsigned long
  ActTimer = millis();
        Player.play(11);                                             //"Beep"
  (active)
        if (millis() - ActTimer > 2000) {
          ActTimer = millis();

        }
        Override = 0;                                               //Taster
  gedrckt, war vorher ausgeschaltet => System wird eingeschaltet
      }
      switch
  (Override) {
        case 1:
          Pointer = 1;                                              //Bleib
  in der Schleife
          delay(500);
          break;
        case 0:

          Pointer = 2;                                              //Frage nach
  REV
          delay(500);
          break;
      }
      Serial.println(Pointer);
                                      //Ausgabe des nchsten Pointers
    break;


    case 2:                                                    //REV Prfen (1,3)

      if (digitalRead(REV) == HIGH) {
          Pointer = 3;                                              //Rckwrtsgang
  aktiv => 3 (Messen)                                             
          Unschaerfe
  = 0;
      }
      else
        Pointer = 1;                                                //Rckwrtsgang
  nicht aktiv => 1
      Serial.println(Pointer);                                      //Ausgabe
  des nchsten Pointers
    break;

    case 3:                                                    //Messen,
  Ausgeben (1)
      Messen();
      Auswertung();
      Ausgabe();
      Pointer
  = 1;
      Serial.println(Pointer);
    break;

    case 4:                                                   //Fehlerzustand

        while (Fehler == true){
          if(digitalRead(REV) == HIGH && FehlerCount
  == 1){
            delay(500);
            Player.play(16);                              //"TAS
  unavailable"
            FehlerCount = 0;
            delay(1000);
          }

          if (digitalRead(REV) == LOW && FehlerCount == 0){
             FehlerCount
  = 1;
             delay(500);
          }
          if (digitalRead(OVR)
  == HIGH && OVR_Fehler == 0){ //"TAS unavailabl                                                                 e"
  Ansage aus
            FehlerCount = 2;
            OVR_Fehler = 1;
            Player.play(11);
                                                                                                          //"BeepBeep"
  fr Aus
            delay(500);
            Player.play(11);
            Serial.println("Ansage
  aus");
            delay(500);
          }
          if (digitalRead(OVR)
  == HIGH && OVR_Fehler == 1){ //"TAS unavailabl                                                                 e"
  Ansage an
            FehlerCount = 1;
            OVR_Fehler = 0;
            Player.play(11);
                                // "Beep" fr An 
            Serial.println("Ansage
  an");
            delay(500);
          }
        }
    break;

  }
}

//------------------------------------------------------------------------

void
  BootUp(){

  
  Messen();
  if (DisR && DisL >= 10){
     Fehler
  = false;
     delay(1000);
     Player.play(14);                                          //"TAS-Test
  Completed"
     delay(4500);
  }
  else {
     Fehler = true;
     Serial.print("Unable
  to begin: Fehler ");
     Serial.println(Fehler);
     Player.play(15);                                          //"Test
  Fail"
     delay(2500);
     Pointer = 4;
  }
}

void Messen()
  {
  digitalWrite(TriggerL, HIGH);                               //Links messen

  delayMicroseconds(20);
  digitalWrite(TriggerL, LOW);
  durationL = pulseIn(EchoL,
  HIGH);
  DisL = durationL * 0.034 / 2;
  Serial.print(DisL);

  digitalWrite(TriggerR,
  HIGH);                               //Rechts messen
  delayMicroseconds(20);

  digitalWrite(TriggerR, LOW);
  durationR = pulseIn(EchoR, HIGH);
  DisR
  = durationR * 0.034 / 2;
  Serial.print("\	");
  Serial.println(DisR);


  if (DisL < DisR) {
    Distanz = DisL;                                           //Vergleichen
                                          und das geringere Ergebniss ausgeben

  }
  else if (DisL == DisR) {
    Distanz = DisL;                                           //DisL
  bekommt                                                         immer die Priorität!

  } 
  else {
    Distanz = DisR;
  }
  Serial.print("\	");Serial.print("\	");Serial.print("\	");

  Serial.println(Distanz);
}
                                                                                 //==========================================//
void
  Auswertung() {                                                                                      //
  Unschaerfe ist eine Variable             //
  if (Distanz >= 20 && Distanz <=
  30) {               //0,2 - 0,3 -> 20         // die Wahrschienlichkeit einer Kritischen
  //
    Zone = 1;                                                                   //
  Distanz. (unter 20cm)                    //
    Unschaerfe = 1;                                                             //==========================================//

  }
  if (Distanz >= 31 && Distanz <= 40) {               //0,3 - 0,4 -> 30

    Zone = 2;
    Unschaerfe = 1;
  }
  if (Distanz >= 41 && Distanz <=
  50) {               //0,4 - 0,5 -> 40
    Zone = 3;
    Unschaerfe = 1;

  }
  if (Distanz >= 51 && Distanz <= 60) {               //0,5 - 0,6 -> 50

    Zone = 4;
    Unschaerfe = 1;
  }
  if (Distanz >= 61 && Distanz <=
  80) {               //0,6 - 0,8 -> 60
    Zone = 5;
    Unschaerfe = 0;

  }
  if (Distanz >= 81 && Distanz <= 100) {              //0,8 - 1m  -> 80

    Zone = 6;
    Unschaerfe = 0;
  }
  if (Distanz >= 101 && Distanz <=
  140) {             //1 - 1,4m  -> 100
    Zone = 7;
    Unschaerfe = 0;

  }
  if (Distanz >= 141 && Distanz <= 200){              //1,4 - 2m  -> 150

    Zone = 8;
    Unschaerfe = 0;
  }
  if (Distanz >= 201 && Distanz <=
  250){              //2 - 2,5m  -> 200
    Zone = 9;
    Unschaerfe = 0;

  }
  if (Distanz >= 250 && Distanz <= 400){               //2,5 - 4m  -> 250

    Zone = 10;
    Unschaerfe = 0;
  }
  if (Distanz >= 401 && Unschaerfe
  == 1){             //<0,2  -> terrain
    Zone = 11;
  }
  if (Distanz
  >= 401 && Unschaerfe == 0){
    Zone = 0;
  }  
  Serial.print("\	");Serial.print("\	");Serial.print("Zone:
  ");
  Serial.println(Zone);
}


void Ausgabe() {
  switch (Zone)
  {
    case 0:
       Player.play(19);                               //-Stille-

    break;
    
    case 1:
      Player.play(13);                                //"Terrain"

      delay(500);
    break;

    case 2:
      Player.play(2);                                //"30"

      delay(500);
      Player.play(12);                                 //"retard"

      delay(500);
    break;

    case 3:
      Player.play(3);                                //"40"

      delay(500);
      Player.play(12);                                 //"retard"

      delay(500);
    break;

    case 4:
      Player.play(4);                                //"50"

      delay(500);
      Player.play(12);                                 //"retard"

      delay(500);       
    break;

    case 5:
      Player.play(5);
                                //"60"
      delay(500);
    break;


    case 6:
      Player.play(6);                                //"80"

      delay(500);
    break;

    case 7:
      Player.play(7);                                //"100"

      delay(500);
    break;

    case 8:
      Player.play(8);                                 //"150"

      delay(500);
    break;

    case 9:
      Player.play(9);                                 //"200"

      delay(500);
    break;

    case 10:
      Player.play(10);                                 //"250"

      delay(500);
    break;  
     
    case 11:
      Player.play(13);
                                 //"Terrain, Terrain"
      delay(500);

    break;
  }
}

Downloadable files

Wiring Amplifier

Circuid Board for the 12V Amplifier

Wiring Amplifier

Wiring Arduino_Stufe

Circuit Board for the Arduino and MP3-Player

Wiring Arduino_Stufe

Zustandsautomat

This might be a little help to you, if you want to write your own Code, or just try to understand mine.

Zustandsautomat

Wiring Sensor_Stufe external

Circuit Board for Sensors if you need to install them external

Wiring Sensor_Stufe external

Circuit Boards soldered together

You need to solder it in this order: 1. Sensor Board 2. Adruino Board 3. Amplifier Board Notice that, if you use double sided circuid borads, you need to isolate every bridge to avoid a short circuit

Circuit Boards soldered together

Wiring Sensor_Stufe external

Circuit Board for Sensors if you need to install them external

Wiring Sensor_Stufe external

Circuit Boards soldered together

You need to solder it in this order: 1. Sensor Board 2. Adruino Board 3. Amplifier Board Notice that, if you use double sided circuid borads, you need to isolate every bridge to avoid a short circuit

Circuit Boards soldered together

Wiring Arduino_Stufe

Circuit Board for the Arduino and MP3-Player

Wiring Arduino_Stufe

Wiring Amplifier

Circuid Board for the 12V Amplifier

Wiring Amplifier

Zustandsautomat

This might be a little help to you, if you want to write your own Code, or just try to understand mine.

Zustandsautomat

Wiring Sensor_Stufe Integrated

Circuit Board for integrated Sensors

Wiring Sensor_Stufe Integrated

Documentation

Case (external Sensors)

Case if you need to install the Sensors somewhere else in your car

Case (external Sensors)

PDC Case (internal sensors)

Case for the PDC with integrated sensor circuit board

PDC Case (internal sensors)

Panel

You can use this to able or enable the sensors

Panel

You can use this to able or enable the sensors

Panel

PDC Case (internal sensors)

Case for the PDC with integrated sensor circuit board

PDC Case (internal sensors)

Case (external Sensors)

Case if you need to install the Sensors somewhere else in your car

Case (external Sensors)

Comments

Only logged in users can leave comments

someone98

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content