Advertisement
Guest User

Source-Code Group2

a guest
Nov 14th, 2023
36
0
120 days
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.83 KB | Source Code | 0 0
  1. #include "DHT.h"
  2.  
  3. // ---------- Festlegung der Variablen und Pins
  4.  
  5. // Festlegung des Temperatursensors:
  6. #define DHTPIN 2 // Pin zum DHT Sensor
  7. #define DHTTYPE DHT11 // Typ des Sensors (DHT 11)
  8.  
  9. // Festlegung der LEDs:
  10. #define RED 6 // Rote LED auf Pin 6
  11. #define GREEN 5 // Grüne LED auf Pin 5
  12. #define BLUE 3 // Blaue LED auf Pin 3
  13.  
  14. // Festlegung des Bewegungssensors:
  15. int inputPin = 4; // Festlegung des Inputs der Daten
  16. int bewegung = LOW; // Keine Bewegung als Standartwert
  17. int pinStatus = 0; // Variable um den Pin-Status auszulesen
  18.  
  19. // Festlegung des Lichtsensors:
  20. int LDR = A2; // Analoger Pin als LDR Eingang
  21. int sensorWert = 0; // Variable für den Sensorwert mit 0 als Startwert
  22.  
  23. // Feste Variablen:
  24. int redValue; // Variable, die den Rotwert (0-255) speichert
  25. int greenValue; // Variable, die den Grünwert (0-255) speichert
  26. int blueValue; // Variable, die den Blauwert (0-255) speichert
  27. int redOldValue; // Variable, die den vorherigen Rotwert (0-255) speichert
  28. int greenOldValue; // Variable, die den vorherigen Grünwert (0-255) speichert
  29. int blueOldValue; // Variable, die den vorherigen Blauwert (0-255) speichert
  30. int farbwert = 0; // Variable, die den Farbwert festlegt, um eine Unterscheidung der Farben zu ermöglichen
  31. int oldFarbwert; // Variable, die den alten Farbwert speichert, um eine Änderung feststellen zu können
  32. int zaehler = 0; // Variable, die genutzt wird, um die Anzahl der Durchgänge mit Beleuchtung zu zählen (zählt hoch)
  33. int temperaturSchleife = 0; // Variable, die genutzt wird, um die Temperatur nur in bestimmten Zeitintervallen abzufragen
  34. float h; // Variable, die die Luftfeuchtigkeit speichert
  35. float t; // Variable, die die Temperatur speichert
  36. float f; // Variable, die die Temperatur auf Celsius setzt
  37.  
  38. // Anpassbare Variablen:
  39. int zaehlerwert = 10; // Legt fest, wie lange das Licht nach Auslösung anbleiben soll. Angabe in Durchgängen (z.B. bei 1000 wartezeit und 10 zaehlerwert = 10 Sekunden)
  40. int wartezeit = 1000; // Legt fest nach wieviel Millisekunden die Sensoren reagieren sollen(z.B. 1000ms = 1 Sekunde)
  41. int tempSchleifenZeit = 2; // Legt fest, wann der Temperatursensor messen soll. Angabe in Durchgängen z.B.: 2 = nach 2 Durchgängen wird gemessen (Richtwert = ungefähr 2 Sekunden)
  42.  
  43. DHT dht(DHTPIN, DHTTYPE); // Erstellt die Temperatur
  44.  
  45.  
  46.  
  47.  
  48. // ---------- Erstmaliges Starten des Programms:
  49. void setup() {
  50. Serial.begin(9600); // Öffnet die serielle Konsole
  51. Serial.println("Start!"); // Gibt in der seriellen Konsole an, dass das Programm startet
  52. pinMode(inputPin, INPUT); // Input des Bewegungssensors starten
  53. dht.begin(); // Temperatursensor starten
  54. }
  55.  
  56.  
  57.  
  58.  
  59. // ---------- Hauptprogramm:
  60. void loop() {
  61. // Temperaturmessung:
  62. if (temperaturSchleife == 0 || temperaturSchleife == tempSchleifenZeit) { // Temperatursensor misst beim ersten Durchlauf der Schleife sowie beim Erreichen des Maximalwerts
  63. h = dht.readHumidity(); // Auslesen der Feuchtigkeit in Celsius
  64. t = dht.readTemperature(); // Auslesen der Temperatur
  65. f = dht.readTemperature(false); // Bei True ist es Fahrenheit
  66. // Überprüfung, ob Fehler beim Auslesen sind:
  67. if (isnan(h) || isnan(t) || isnan(f)) {
  68. Serial.println(F("Fehler beim Auslesen!"));
  69. return;
  70. }
  71. // Ausgabe der Werte:
  72. Serial.print(F("Humidity: "));
  73. Serial.print(h);
  74. Serial.print(F("% Temperature: "));
  75. Serial.print(t);
  76. Serial.println(F("°C "));
  77. temperaturSchleife = 1; // Setzt die Schleife auf 1, sobald gemessen wurde
  78. }
  79.  
  80. // Bewegungsmessung:
  81. pinStatus = digitalRead(inputPin); // Liest den Inputwert aus
  82. if (pinStatus == HIGH) { // Überprüft, ob der Input High ist (Datenfluss)
  83. if (bewegung == LOW) { // Wenn die bewegung-Variable low ist, soll sie auf HIGH gesetzt werden
  84. Serial.println("Motion detected");
  85. zaehler = 1; // Da Bewegung vorhanden war, wird die Zählschleife zur Aktivierung des Lichts gestartet
  86. bewegung = HIGH; // Bewegung wird auf High gesetzt
  87. }
  88. }
  89. else {
  90. if (bewegung == HIGH){
  91. Serial.println("Motion stopped");
  92. bewegung = LOW;
  93. }
  94. }
  95.  
  96. delay(wartezeit); // Wartezeit zwischen den Messungen
  97. Serial.print(F("Zaehler: ")); // Ausgabe des Zählers zur Nachverfolgung
  98. Serial.println( zaehler ); // Ausgabe des Zählers zur Nachverfolgung
  99.  
  100. // Lichtmessung:
  101. sensorWert = analogRead(LDR); // Wert auslesen
  102. Serial.print(F("Brightness: "));
  103. Serial.println(sensorWert); // Ausgabe am Serial-Monitor
  104.  
  105. // Ausschalten der LEDs:
  106. // Wenn der zaehler 5 ist, wird die LED ausgeschaltet:
  107. if ( zaehler == zaehlerwert) { // Wenn der zaehler den zaehlerwert erreicht hat, wird das Licht ausgeschaltet
  108. zaehler = 0; // zaehler wird auf 0 gesetzt, um eine neue Auslösung zu ermöglichen
  109. Serial.println( "LIGHTS OFF" );
  110. analogWrite(RED, 0);
  111. analogWrite(GREEN, 0);
  112. analogWrite(BLUE, 0);
  113. farbwert = 0; // Farbwert wird gesetzt, um eine Farbänderung nach Ausschalten feststellen zu können
  114. }
  115.  
  116. // Auswertung ob LEDs eingeschaltet werden müssen:
  117. if (sensorWert > 300) { // Wenn es dunkler als 300 ist, dann passiert das folgende (Im Test war ein Wert von 500 Dunkel):
  118. Serial.print("Dunkel --> Wert: "); // Ausgabe der Dunkelheit
  119. Serial.println(sensorWert);
  120. if (zaehler < zaehlerwert && zaehler != 0) { // Wenn Bewegung erfolgt ist und damit die Zaehlschleife aktiv wurde, setze die Farben anhand der Temperatur:
  121. if ( t >= 25 ) {
  122. Serial.println( "Temperature-Color: PINK" );
  123. farbwert = 1; // Ermöglicht die einfache Unterscheidung, um Wechsel der Farben zu ermöglichen
  124. redValue = 255;
  125. greenValue = 0;
  126. blueValue = 255;
  127. }
  128. else if ( t >= 24 && t < 25) {
  129. Serial.println( "Temperature-Color: RED" );
  130. farbwert = 2;
  131. redValue = 255;
  132. greenValue = 0;
  133. blueValue = 0;
  134. }
  135. else if ( t >= 23 && t < 24) {
  136. Serial.println( "Temperature-Color: ORANGE" );
  137. farbwert = 3;
  138. redValue = 255;
  139. greenValue = 140;
  140. blueValue = 26;
  141. }
  142. else if ( t >= 22 && t < 23) {
  143. Serial.println( "Temperature-Color: YELLOW" );
  144. farbwert = 4;
  145. redValue = 255;
  146. greenValue = 255;
  147. blueValue = 0;
  148. }
  149. else if ( t >= 21 && t < 22) {
  150. Serial.println( "Temperature-Color: GREEN" );
  151. farbwert = 5;
  152. redValue = 0;
  153. greenValue = 255;
  154. blueValue = 0;
  155. }
  156. else if ( t >= 20 && t < 21) {
  157. Serial.println( "Temperature-Color: TURQUOISE" );
  158. farbwert = 6;
  159. redValue = 100;
  160. greenValue = 255;
  161. blueValue = 255;
  162. }
  163. else if ( t < 20) {
  164. Serial.println( "Temperature-Color: BLUE" );
  165. farbwert = 7;
  166. redValue = 0;
  167. greenValue = 0;
  168. blueValue = 255;
  169. }
  170. // Temperatur-Unterschiede - ÜBerprüfung ob Farbe geändert werden muss:
  171. if ( farbwert != oldFarbwert) { // Wenn sich die neue Farbe nicht gleich dem alten Farbwert ist, dann mache das folgende:
  172. for(int i = 0; i < 255; i += 1) { // For-Schleife um Werte langsam zu ändern
  173. // Rote Farbe:
  174. if (redValue > redOldValue) { // Wenn der neue Farbwert größer ist als der alte (z.B. 255 statt 100)
  175. redOldValue += 1;
  176. }
  177. else if (redValue < redOldValue) { // Wenn der neue Farbwert kleiner ist als der alte (z.B. 100 statt 255)
  178. redOldValue -= 1;
  179. }
  180. // Grüne Farbe:
  181. if (greenValue > greenOldValue) { // Wenn der neue Farbwert größer ist als der alte (z.B. 255 statt 100)
  182. greenOldValue += 1;
  183. }
  184. else if (greenValue < greenOldValue) { // Wenn der neue Farbwert kleiner ist als der alte (z.B. 100 statt 255)
  185. greenOldValue -= 1;
  186. }
  187. // Blaue Farbe:
  188. if (blueValue > blueOldValue) { // Wenn der neue Farbwert größer ist als der alte (z.B. 255 statt 100)
  189. blueOldValue += 1;
  190. }
  191. else if (blueValue < blueOldValue) { // Wenn der neue Farbwert kleiner ist als der alte (z.B. 100 statt 255)
  192. blueOldValue -= 1;
  193. }
  194. // Ändern der Farbe im Abstand von 10 ms:
  195. analogWrite(RED, redOldValue);
  196. analogWrite(GREEN, greenOldValue);
  197. analogWrite(BLUE, blueOldValue);
  198. delay(10);
  199. }
  200. }
  201. zaehler++; // zaehler zählt hoch, um ein Anbleiben der Lichter zu ermöglichen
  202. }
  203. // Merken der alten Farbwerte, für zukünftigen Vergleich:
  204. redOldValue = redValue;
  205. greenOldValue = greenValue;
  206. blueOldValue = blueValue;
  207. oldFarbwert = farbwert;
  208. }
  209. // Falls es zu hell ist, mache das folgende:
  210. else{
  211. Serial.println("Bright");
  212. if( zaehler <= zaehlerwert && zaehler != 0 ) // Zähler wird trotzdem hochgezählt, obwohl es hell wurde, damit das Licht anbleibt
  213. {
  214. zaehler++;
  215. }
  216. }
  217. temperaturSchleife++; // Temperaturschleife zählt hoch, um den Abstand der Messungen festlegen zu können
  218. Serial.println("-------------------");
  219. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement