Advertisement
Guest User

Untitled

a guest
Mar 1st, 2015
192
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.09 KB | None | 0 0
  1. int val= 0;
  2. int compare=0;
  3.  
  4. int TorOffen = 3;
  5. int LEDROT = 13;
  6. int LEDGR = 5;
  7. int Lampe = 7;
  8. int zaehler = 0;
  9.  
  10. int Relais = 2;
  11. int TorZu = 4;
  12. int Summer = 9;
  13.  
  14. #define c 261
  15. #define d 293
  16. #define e 329
  17. #define f 349
  18. #define g 391
  19. #define a 493
  20. #define b 493
  21. #define C 523
  22.  
  23.  
  24. void setup(){
  25. pinMode(LEDROT, OUTPUT);
  26. Ausschalten(LEDROT);
  27.  
  28. pinMode(LEDGR, OUTPUT);
  29. Ausschalten (LEDGR);
  30.  
  31. pinMode(Relais, OUTPUT);
  32. Ausschalten(Relais);
  33.  
  34. pinMode(TorOffen, INPUT);
  35. pinMode(TorZu, INPUT);
  36.  
  37. pinMode(Lampe, OUTPUT);
  38. Ausschalten(Lampe);
  39.  
  40. //Verbindung zum PC aufbauen:
  41. Serial.begin(9600);
  42. }
  43.  
  44. void loop(){
  45.  
  46. SendeAnPC("Start");
  47. while(digitalRead(TorZu)==HIGH){
  48. WarteSekunden(100);
  49. }
  50. SendeAnPC("Lampe An 1 ");
  51. Anschalten(Lampe);
  52. WarteSekunden(2000); // AN
  53. Ausschalten(Lampe);
  54.  
  55. SendeAnPC("Tor oeffnet");
  56.  
  57. while(digitalRead(TorOffen)==LOW){
  58. WarteSekunden(100);
  59. }
  60. SendeAnPC("Lampe Aus 1 ");
  61. Anschalten(Lampe);
  62. WarteSekunden(2000); // AUS
  63. Ausschalten(Lampe);
  64.  
  65.  
  66.  
  67. if (digitalRead(TorOffen)==HIGH){
  68. SendeAnPC("Warte bis Tor offen");
  69. while(digitalRead(TorOffen)==LOW){
  70. WarteSekunden(0);
  71. }
  72. SendeAnPC("Tor offen");
  73. SendeAnPC("warte eingestellte Zeit");
  74. TonSpielen(b, 300);
  75.  
  76. zaehler = 0;
  77. while( zaehler < 8){ //bei 1200ms = 50 mal = 1 Minute
  78. Anschalten(LEDGR);
  79. WarteSekunden(500);
  80. Ausschalten(LEDGR);
  81. WarteSekunden(100);
  82. Anschalten(LEDROT);
  83. WarteSekunden(500);
  84. Ausschalten(LEDROT);
  85. if (digitalRead(TorOffen)==LOW){
  86. SendeAnPC("Tor im warten schon manuell geschlossen");
  87. SendeAnPC("Lampe An 1/1");
  88. Anschalten(Lampe);
  89. WarteSekunden(2000); // An
  90. Ausschalten(Lampe);
  91. zaehler = 0;
  92. while( zaehler < 8){ //bei 1200ms = 50 mal = 1 Minute
  93. Anschalten(LEDGR);
  94. WarteSekunden(500);
  95. Ausschalten(LEDGR);
  96. WarteSekunden(100);
  97. Anschalten(LEDROT);
  98. WarteSekunden(500);
  99. Ausschalten(LEDROT);
  100. WarteSekunden(100);
  101. zaehler = zaehler + 1; //macht das gleiche wie zaehler++;
  102. while (digitalRead(TorZu)==LOW){
  103. WarteSekunden(100);
  104. }
  105. SendeAnPC("Lampe Aus 1/1");
  106. Anschalten(Lampe);
  107. WarteSekunden(2000); // Aus
  108. Ausschalten(Lampe);
  109. return;
  110. }
  111. }
  112. WarteSekunden(100);
  113. zaehler = zaehler + 1; //macht das gleiche wie zaehler++;
  114. }
  115. }else{
  116. SendeAnPC("warte bis zu ist");
  117. while (digitalRead(TorZu)==LOW)
  118. WarteSekunden(100);
  119. SendeAnPC("Ende eig.");
  120. }
  121.  
  122. SendeAnPC("warten vorbei - pruefe ob Tor noch offen");
  123. if (digitalRead(TorOffen)==HIGH){ // wenn Tor immernoch oben ist, geht es hier weiter
  124. SendeAnPC("Tor noch offen");
  125. WarteSekunden(200);
  126. Anschalten(LEDGR);
  127. TonSpielen(a, 1000);
  128. WarteSekunden(1000);
  129. Ausschalten(LEDGR);
  130. WarteSekunden(200);
  131. Anschalten(LEDGR);
  132. TonSpielen(g, 1000);
  133. WarteSekunden(1000);
  134. Ausschalten(LEDGR);
  135. WarteSekunden(200);
  136. Anschalten(LEDGR);
  137. TonSpielen(b, 1000);
  138. WarteSekunden(1000);
  139. Ausschalten(LEDGR);
  140. WarteSekunden(100);
  141. SendeAnPC("Tor schliesst");
  142. Anschalten(Relais);
  143. WarteSekunden(500);
  144. Ausschalten(Relais);
  145.  
  146. while(digitalRead(TorOffen)==LOW){
  147. WarteSekunden(100);
  148.  
  149. SendeAnPC("Lampe An 2");
  150. Anschalten(Lampe);
  151. WarteSekunden(2000); // An
  152. Ausschalten(Lampe);
  153. }
  154.  
  155. } else { // wenn Tor nicht oben ist, geht es hier weiter
  156. SendeAnPC("Tor nicht erkennbar");
  157. Anschalten(LEDROT);
  158. TonSpielen(a, 100);
  159. WarteSekunden(100);
  160. Ausschalten(LEDROT);
  161. WarteSekunden(100);
  162. Anschalten(LEDROT);
  163. TonSpielen(g, 100);
  164. WarteSekunden(100);
  165. Ausschalten(LEDROT);
  166. WarteSekunden(100);
  167. Anschalten(LEDROT);
  168. TonSpielen(a, 100);
  169. WarteSekunden(100);
  170. Ausschalten(LEDROT);
  171. }
  172. SendeAnPC("warte bis Tor evt. geschlossen");
  173.  
  174. zaehler = 0;
  175. while( zaehler < 8){ //bei 1200ms = 50 mal = 1 Minute
  176. Anschalten(LEDGR);
  177. WarteSekunden(500);
  178. Ausschalten(LEDGR);
  179. WarteSekunden(100);
  180. Anschalten(LEDROT);
  181. WarteSekunden(500);
  182. Ausschalten(LEDROT);
  183. WarteSekunden(100);
  184. zaehler = zaehler + 1; //macht das gleiche wie zaehler++;
  185. }
  186.  
  187. if(digitalRead(TorOffen)==LOW){
  188. WarteSekunden(0);
  189.  
  190. SendeAnPC("Lampe An 3");
  191. Anschalten(Lampe);
  192. WarteSekunden(2000); // An
  193. Ausschalten(Lampe);
  194. WarteSekunden(2000);
  195. }
  196.  
  197. if (digitalRead(TorZu) == LOW){ // Test ob Tor geschlossen ist
  198. SendeAnPC("Tor noch offen");
  199. Anschalten(LEDROT);
  200. WarteSekunden(200);
  201. Ausschalten(LEDROT);
  202. TonSpielen(a, 2000);
  203. Anschalten(LEDROT);
  204. WarteSekunden(200);
  205. Ausschalten(LEDROT);
  206. WarteSekunden(200);
  207. Anschalten(LEDROT);
  208. WarteSekunden(200);
  209. Ausschalten(LEDROT);
  210. WarteSekunden(200);
  211. Anschalten(LEDROT);
  212. WarteSekunden(200);
  213. Ausschalten(LEDROT);
  214. WarteSekunden(200);
  215. Anschalten(LEDROT);
  216. WarteSekunden(200);
  217. Ausschalten(LEDROT);
  218. WarteSekunden(200);
  219. Anschalten(LEDROT);
  220. WarteSekunden(200);
  221. Ausschalten(LEDROT);
  222. WarteSekunden(200);
  223. Anschalten(LEDROT);
  224. WarteSekunden(200);
  225. Ausschalten(LEDROT);
  226. WarteSekunden(200);
  227. Anschalten(LEDROT);
  228. WarteSekunden(200);
  229. Ausschalten(LEDROT);
  230. SendeAnPC("warte bis zu");
  231.  
  232. zaehler = 0;
  233. while( zaehler < 8){ //bei 1200ms = 50 mal = 1 Minute
  234. Anschalten(LEDGR);
  235. WarteSekunden(500);
  236. Ausschalten(LEDGR);
  237. WarteSekunden(100);
  238. Anschalten(LEDROT);
  239. WarteSekunden(500);
  240. Ausschalten(LEDROT);
  241. WarteSekunden(100);
  242. zaehler = zaehler + 1; //macht das gleiche wie zaehler++;
  243. }
  244.  
  245. if(digitalRead(TorZu)==HIGH);{
  246. SendeAnPC("Lampe Aus 3");
  247. Anschalten(Lampe);
  248. WarteSekunden(2000); // AUS
  249. Ausschalten(Lampe);
  250.  
  251.  
  252. }
  253.  
  254. while(digitalRead(TorZu)==LOW);
  255.  
  256.  
  257. } else { //Tor geschlossen
  258.  
  259. if(digitalRead(TorZu)==HIGH){
  260. WarteSekunden(0);
  261.  
  262. SendeAnPC("Lampe Aus 4");
  263. Anschalten(Lampe);
  264. WarteSekunden(2000); // AUS
  265. Ausschalten(Lampe);
  266.  
  267. Anschalten(LEDGR);
  268. TonSpielen(a, 100);
  269. WarteSekunden(100);
  270. Ausschalten(LEDGR);
  271. WarteSekunden(100);
  272. Anschalten(LEDGR);
  273. TonSpielen(g, 100);
  274. WarteSekunden(100);
  275. Ausschalten(LEDGR);
  276.  
  277. SendeAnPC("Tor ist geschlossen");
  278. SendeAnPC("-- E N D E -- ");
  279. // eigentlich nix tun, oder?
  280. }
  281. }
  282. //beginnt wieder oben
  283. }
  284.  
  285. //Hilfs-Funktionen:
  286.  
  287. void Anschalten(int pin) {
  288. digitalWrite(pin, HIGH);
  289. }
  290.  
  291. void Ausschalten(int pin) {
  292. digitalWrite(pin, LOW);
  293. }
  294.  
  295. void AnFuerSekunden(int pin, int sekunden) {
  296. Anschalten(pin);
  297. WarteSekunden(sekunden * 1000);
  298. Ausschalten(pin);
  299. }
  300.  
  301. void TonSpielen(int ton, int sekunden){
  302. tone(Summer, ton, sekunden);
  303. }
  304.  
  305. void WarteSekunden(int sekunden) {
  306. delay(sekunden);
  307. }
  308.  
  309. void WarteMinuten(int minuten){
  310. WarteSekunden(60 * minuten);
  311. }
  312.  
  313. void SendeAnPC(char* nachricht){
  314. Serial.println(nachricht);
  315. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement