ActionPi is an easy to use Action Camera for the Raspberry Pi.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

ActionPi.cpp 19KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757
  1. /*
  2. * ActionPi.cpp
  3. * Version 1.02
  4. * IT-Hardware Projekt GWS-Bühl
  5. * Copyright 2016 <admin@kellerkinder.xyz>
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License as published by
  9. * the Free Software Foundation; either version 2 of the License, or
  10. * (at your option) any later version.
  11. *
  12. * This program is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. * GNU General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with this program; if not, write to the Free Software
  19. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  20. * MA 02110-1301, USA.
  21. *
  22. *zum kompilieren ---> g++ -Wall "%f" -o"%e" -l raspicam -l bcm2835 -std=c++0x
  23. *oder---> g++ -Wall "%f" -o"%e" -l raspicam -l bcm2835 -std=c++14
  24. */
  25. #include <iostream>
  26. #include <stdio.h>
  27. #include <time.h>
  28. #include <string>
  29. #include <stdlib.h>
  30. #include <ctime>
  31. #include <algorithm>
  32. #include <fstream>
  33. #include <bcm2835.h>
  34. #include <raspicam/raspicam.h>
  35. #include <unistd.h>
  36. #include <dirent.h>
  37. #include <errno.h>
  38. using namespace std;
  39. string gibDateiName();
  40. string getFolderName();
  41. void videoAufnehmen();
  42. int fotoAufnehmen();
  43. void liveAusgabe();
  44. void videoAbspeichern();
  45. void initialisierung();
  46. void blinken();
  47. void herunterfahren();
  48. void programmBeenden();
  49. void convert();
  50. void creatNewFolder();
  51. void creatDCIM();
  52. bool ordnerExistiert(string pfad);
  53. void pruefeNewFolder(string input);
  54. void rueckschau(string input);
  55. void setStandardWerte();
  56. void einstellungen();
  57. void einstellungErhoehen();
  58. void einstellungVerringern();
  59. void zuruecksetzten();
  60. void iso(int richtung);
  61. void helligkeit(int richtung);
  62. void kontrast(int richtung);
  63. void saettigung(int richtung);
  64. void verschlusszeit(int richtung);
  65. void setISO ( int iso );
  66. void setBrightness ( unsigned int brightness );
  67. void setContrast ( int contrast );
  68. void setSaturation ( int saturation );
  69. void setExposureCompensation ( int val );
  70. void setShutterSpeed ( unsigned int ss );
  71. int getMODI();
  72. int getREC();
  73. int getEx1();
  74. int getEx2();
  75. int getEx3();
  76. #define LED RPI_V2_GPIO_P1_13
  77. #define MODI RPI_V2_GPIO_P1_22
  78. #define REC RPI_V2_GPIO_P1_18
  79. #define Ex1 RPI_V2_GPIO_P1_16
  80. #define Ex2 RPI_V2_GPIO_P1_15
  81. #define Ex3 RPI_V2_GPIO_P1_11
  82. int valMODI;
  83. int valREC;
  84. int valEx1;
  85. int valEx2;
  86. int valEx3;
  87. int valISO;
  88. int valHelligkeit;
  89. int valKontrast;
  90. int valSaettigung;
  91. int valVerschlusszeit;
  92. int zaehlerISO = 1;
  93. int zaehlerHelligkeit = 1;
  94. int zaehlerKontrast = 1;
  95. int zaehlerSaettigung = 2;
  96. int zaehlerVerschlusszeit = 4;
  97. int einstellung = 0; // 0=Verschlusszeit;1=ISO;2=Kontrast;3=Helligkeit;4=Sättigung;
  98. int wieLangeGedrueckt = 0;
  99. bool aktiv = true;
  100. bool videoAufnahme = false;
  101. bool liveBildWirdAngezeigt = false;
  102. int main(int argc, char **argv)
  103. {
  104. creatDCIM(); //prüft ob DCIM Ordner existiert, sollt er nicht existieren wird er erstellt
  105. creatNewFolder(); //prüft ob Datums-Ordner existiert, sollt er nicht existieren wird er erstellt
  106. if (!bcm2835_init())
  107. return 1;
  108. initialisierung();
  109. setStandardWerte();
  110. while (aktiv)
  111. {
  112. if(videoAufnahme && getMODI() )
  113. {
  114. videoAbspeichern();
  115. }
  116. if(!liveBildWirdAngezeigt)
  117. {
  118. liveAusgabe(); // Live-Ausgabe wird gestartet
  119. }
  120. if(getREC())
  121. {
  122. //REC Taster gedrückt
  123. if(getMODI())
  124. {
  125. //Fotomodus
  126. fotoAufnehmen();
  127. }
  128. else{
  129. //Videomodus
  130. if(!videoAufnahme)
  131. {
  132. videoAufnehmen();
  133. delay(1000); // mindestens 1sec Video
  134. }
  135. else{
  136. videoAbspeichern();
  137. }
  138. }
  139. }
  140. if(getMODI()){ // Eindtellungen nur im Fotomodus
  141. einstellungen();
  142. einstellungErhoehen();
  143. einstellungVerringern();
  144. zuruecksetzten();
  145. }
  146. delay(100);
  147. programmBeenden(); // prüft ob das Programm beendet werden soll
  148. herunterfahren(); // prüft ob der Pi heruntergefahren werden soll
  149. } //while Ende
  150. bcm2835_close();
  151. return 0;
  152. }
  153. //setzt Fotoeinstellungen zurück
  154. void zuruecksetzten()
  155. {
  156. if(getEx2()){
  157. if(wieLangeGedrueckt < 20){
  158. wieLangeGedrueckt = wieLangeGedrueckt +1;
  159. //cout<<wieLangeGedrueckt<<endl;
  160. }
  161. else{
  162. wieLangeGedrueckt = 0;
  163. cout<<"Zurückgesetzt"<<endl;
  164. blinken();
  165. setStandardWerte();
  166. }
  167. }
  168. return;
  169. }
  170. //öffnet Einstellungen und zeigt die verschiedenen Optionen an
  171. void einstellungen()
  172. {
  173. if(getEx2()){
  174. delay(100);
  175. einstellung = einstellung +1;
  176. if(einstellung == 5){
  177. einstellung = 0;
  178. }
  179. //cout<<einstellung<<endl;
  180. if(einstellung ==1){
  181. cout<<"ISO:";
  182. cout<<valISO<<endl;
  183. }
  184. if(einstellung == 3){
  185. cout<<"Helligkeit:";
  186. cout<<valHelligkeit<<endl;
  187. }
  188. if(einstellung == 2){
  189. cout<<"Kontrast:";
  190. cout<<valKontrast<<endl;
  191. }
  192. if(einstellung == 4){
  193. cout<<"Saettigung:";
  194. cout<<valSaettigung<<endl;
  195. }
  196. if(einstellung == 0){
  197. cout<<"Verschlusszeit:";
  198. cout<<valVerschlusszeit<<endl;
  199. }
  200. }
  201. return;
  202. }
  203. //setzt die gewählte Einstellung auf den nächts höheren Wert
  204. void einstellungErhoehen()
  205. {
  206. if(getEx3()){
  207. delay(100);
  208. wieLangeGedrueckt = 0;
  209. if(einstellung == 1){
  210. //ISO
  211. iso(1);
  212. }
  213. if(einstellung == 3){
  214. //Helligkeit
  215. helligkeit(1);
  216. }
  217. if(einstellung == 2){
  218. //Kontrast
  219. kontrast(1);
  220. }
  221. if(einstellung == 4){
  222. //Sättigung
  223. saettigung(1);
  224. }
  225. if(einstellung == 0){
  226. //Verschlusszeit
  227. verschlusszeit(1);
  228. }
  229. }
  230. return;
  231. }
  232. //setzt die gewählte Einstellung auf den nächts niedrigeren Wert
  233. void einstellungVerringern()
  234. {
  235. if(getEx1()){
  236. delay(100);
  237. wieLangeGedrueckt = 0;
  238. if(einstellung == 1){
  239. //ISO
  240. iso(-1);
  241. }
  242. if(einstellung == 3){
  243. //Helligkeit
  244. helligkeit(-1);
  245. }
  246. if(einstellung == 2){
  247. //Kontrast
  248. kontrast(-1);
  249. }
  250. if(einstellung == 4){
  251. //Sättigung
  252. saettigung(-1);
  253. }
  254. if(einstellung == 0){
  255. //Verschlusszeit
  256. verschlusszeit(-1);
  257. }
  258. }
  259. return;
  260. }
  261. //Werte für ISO 100,400,600,600,800 min:100; max:800
  262. void iso(int richtung)
  263. {
  264. zaehlerISO = zaehlerISO + (richtung);
  265. if(zaehlerISO == -1){
  266. zaehlerISO = 0;
  267. }
  268. if(zaehlerISO == 4){
  269. zaehlerISO = 3;
  270. }
  271. if(zaehlerISO == 0){
  272. valISO = 100;
  273. cout<<"ISO:";
  274. cout<<valISO<<endl;
  275. }
  276. if(zaehlerISO == 1){
  277. valISO = 400;
  278. cout<<"ISO:";
  279. cout<<valISO<<endl;
  280. }
  281. if(zaehlerISO == 2){
  282. valISO = 600;
  283. cout<<"ISO:";
  284. cout<<valISO<<endl;
  285. }
  286. if(zaehlerISO == 3){
  287. valISO = 800;
  288. cout<<"ISO:";
  289. cout<<valISO<<endl;
  290. }
  291. return;
  292. }
  293. //Werte für Helligkeit 25,50,75,100
  294. void helligkeit(int richtung)
  295. {
  296. zaehlerHelligkeit = zaehlerHelligkeit + (richtung);
  297. if(zaehlerHelligkeit == -1){
  298. zaehlerHelligkeit = 0;
  299. }
  300. if(zaehlerHelligkeit == 4){
  301. zaehlerHelligkeit = 3;
  302. }
  303. if(zaehlerHelligkeit == 0){
  304. valHelligkeit = 25;
  305. cout<<"Helligkeit:";
  306. cout<<valHelligkeit<<endl;
  307. }
  308. if(zaehlerHelligkeit == 1){
  309. valHelligkeit = 50;
  310. cout<<"Helligkeit:";
  311. cout<<valHelligkeit<<endl;
  312. }
  313. if(zaehlerHelligkeit == 2){
  314. valHelligkeit = 75;
  315. cout<<"Helligkeit:";
  316. cout<<valHelligkeit<<endl;
  317. }
  318. if(zaehlerHelligkeit == 3){
  319. valHelligkeit = 100;
  320. cout<<"Helligkeit:";
  321. cout<<valHelligkeit<<endl;
  322. }
  323. return;
  324. }
  325. //Werte für Kontrast -50,0,50,100
  326. void kontrast(int richtung)
  327. {
  328. zaehlerKontrast = zaehlerKontrast + (richtung);
  329. if(zaehlerKontrast == -1){
  330. zaehlerKontrast = 0;
  331. }
  332. if(zaehlerKontrast == 4){
  333. zaehlerKontrast = 3;
  334. }
  335. if(zaehlerKontrast == 0){
  336. valKontrast = -50;
  337. cout<<"Kontrast:";
  338. cout<<valKontrast<<endl;
  339. }
  340. if(zaehlerKontrast == 1){
  341. valKontrast = 0;
  342. cout<<"Kontrast:";
  343. cout<<valKontrast<<endl;
  344. }
  345. if(zaehlerKontrast == 2){
  346. valKontrast = 50;
  347. cout<<"Kontrast:";
  348. cout<<valKontrast<<endl;
  349. }
  350. if(zaehlerKontrast == 3){
  351. valKontrast = 100;
  352. cout<<"Kontrast:";
  353. cout<<valKontrast<<endl;
  354. }
  355. return;
  356. }
  357. //Werte für Sättigung -100,-75,0,50,100
  358. void saettigung(int richtung)
  359. {
  360. zaehlerSaettigung = zaehlerSaettigung + (richtung);
  361. if(zaehlerSaettigung == -1){
  362. zaehlerSaettigung = 0;
  363. }
  364. if(zaehlerSaettigung == 5){
  365. zaehlerSaettigung = 4;
  366. }
  367. if(zaehlerSaettigung == 0){
  368. valSaettigung = -100;
  369. cout<<"Saettigung:";
  370. cout<<valSaettigung<<endl;
  371. }
  372. if(zaehlerSaettigung == 1){
  373. valSaettigung = -75;
  374. cout<<"Saettigung:";
  375. cout<<valSaettigung<<endl;
  376. }
  377. if(zaehlerSaettigung == 2){
  378. valSaettigung = 0;
  379. cout<<"Saettigung:";
  380. cout<<valSaettigung<<endl;
  381. }
  382. if(zaehlerSaettigung == 3){
  383. valSaettigung = 50;
  384. cout<<"Saettigung:";
  385. cout<<valSaettigung<<endl;
  386. }
  387. if(zaehlerSaettigung == 4){
  388. valSaettigung = 100;
  389. cout<<"Saettigung:";
  390. cout<<valSaettigung<<endl;
  391. }
  392. return;
  393. }
  394. //Werte für Verschluss-/Belichtungszeit 0,5000,20000,40000,100000 kleiner = kürzere Verschlusszeit
  395. void verschlusszeit(int richtung)
  396. {
  397. zaehlerVerschlusszeit = zaehlerVerschlusszeit + (richtung);
  398. if(zaehlerVerschlusszeit == -1){
  399. zaehlerVerschlusszeit = 0;
  400. }
  401. if(zaehlerVerschlusszeit == 5){
  402. zaehlerVerschlusszeit = 4;
  403. }
  404. if(zaehlerVerschlusszeit == 0){
  405. valVerschlusszeit = 5000;
  406. cout<<"Verschlusszeit:";
  407. cout<<valVerschlusszeit<<endl;
  408. }
  409. if(zaehlerVerschlusszeit == 1){
  410. valVerschlusszeit = 20000;
  411. cout<<"Verschlusszeit:";
  412. cout<<valVerschlusszeit<<endl;
  413. }
  414. if(zaehlerVerschlusszeit == 2){
  415. valVerschlusszeit = 40000;
  416. cout<<"Verschlusszeit:";
  417. cout<<valVerschlusszeit<<endl;
  418. }
  419. if(zaehlerVerschlusszeit == 3){
  420. valVerschlusszeit = 100000;
  421. cout<<"Verschlusszeit:";
  422. cout<<valVerschlusszeit<<endl;
  423. }
  424. if(zaehlerVerschlusszeit == 4){
  425. valVerschlusszeit = 0;
  426. cout<<"Verschlusszeit:";
  427. cout<<valVerschlusszeit<<endl;
  428. }
  429. return;
  430. }
  431. //wird von void zuruecksetzten() aufgerufen und setzt die Fotoeinstellungen zurück auf den Standartwert
  432. void setStandardWerte()
  433. {
  434. valISO = 400;
  435. valHelligkeit = 50;
  436. valKontrast = 0;
  437. valSaettigung = 0;
  438. valVerschlusszeit = 0;
  439. return;
  440. }
  441. //startet die Videoaufnahme
  442. void videoAufnehmen()
  443. {
  444. bcm2835_gpio_set(LED); //schaltet LED an
  445. videoAufnahme = true; // Merker für aktuelle Videoaufnahme
  446. system("killall raspivid"); //beendet den Prozess raspivid (Liveausgabe)
  447. system("raspivid -o vid.h264 -t 1140000 -p '0,-10,720,480' &"); //nimmt video mit 19 Minuten auf -o temporäre output Datei, -p '0,-10,1280,720' für Position und Größe des Vorschau Bildes
  448. liveBildWirdAngezeigt = false; //setzt Merker für Livebildausgabe
  449. return;
  450. }
  451. //nimmt ein temporäres Foto im ppm Format auf
  452. int fotoAufnehmen()
  453. {
  454. bcm2835_gpio_set(LED); //schaltet LED an
  455. system("killall raspivid");
  456. raspicam::RaspiCam Camera; //definiert Camera Objekt
  457. //setzt die gewählten Fotoeinstellungen
  458. Camera.setISO(valISO);
  459. Camera.setBrightness(valHelligkeit);
  460. Camera.setContrast(valKontrast);
  461. Camera.setSaturation(valSaettigung);
  462. Camera.setShutterSpeed(valVerschlusszeit);
  463. //Öffnet Camera
  464. if ( !Camera.open()) {cerr<<"Fehler beim öffnen der Kamera!"<<endl;return -1;} //gibt Fehlermeldung aus sofern Kamera öffnen nicht möglich
  465. sleep(1); //schlafe 1 Sekunde bis Kamera stabilisiert (ohne Pause wird das Bild rot)
  466. Camera.grab(); //hohle Kamera
  467. //reserviere Speicher
  468. unsigned char *data=new unsigned char[ Camera.getImageTypeSize ( raspicam::RASPICAM_FORMAT_RGB )]; //setzt Bild Format auf RGB
  469. Camera.retrieve ( data,raspicam::RASPICAM_FORMAT_RGB );//aufnehmen des Bildes
  470. std::ofstream outFile ("bild.ppm" ,std::ios::binary ); //speichern des temporären Bildes
  471. outFile<<"P6\n"<<Camera.getWidth() <<" "<<Camera.getHeight() <<" 255\n";
  472. outFile.write ( ( char* ) data, Camera.getImageTypeSize ( raspicam::RASPICAM_FORMAT_RGB ) ); //speichern der zusätzlichen Parameter
  473. delete data; //gibt speicher wieder frei
  474. liveBildWirdAngezeigt = false; //setzt Merker für Livebildausgabe
  475. convert(); //ruft Funktion zum konvertieren des temporären Bildes auf
  476. bcm2835_gpio_clr(LED); //schaltet LED aus
  477. return 1;
  478. }
  479. void liveAusgabe ()
  480. {
  481. liveBildWirdAngezeigt = true; //setzt Merker für Livebildausgabe
  482. system("raspivid -t -0 -p '0,-10,720,480'&"); //-p '0,0,1280,720' für Position und Größe des Vorschau Bildes
  483. return;
  484. }
  485. //konvertiert Video und speichert es auf USB Stick
  486. void videoAbspeichern()
  487. {
  488. bcm2835_gpio_clr(LED); //schaltet LED aus
  489. std::string datname = gibDateiName(); //holen des Dateinamen
  490. std::string ordnerName = getFolderName(); //holen des Ordnernamen
  491. pruefeNewFolder(ordnerName); //prüfen ob Ordner bereits existiert
  492. std::string cmd_line = std::string() + " sudo MP4Box -fps 30 -add vid.h264 /media/usb0/DCIM/"+ordnerName+"/""\"" +datname+"\".mp4 "; //Befehl zu packen von video in .mp4 container
  493. system( cmd_line.c_str() ); //ruft pack befehl auf
  494. system("killall raspivid");//beendet video aufnahme
  495. system("rm vid.h264"); //löscht temporäre vid.h264 video datei
  496. videoAufnahme = false; //Merker für Videoaufnahme
  497. liveBildWirdAngezeigt = false;//setzt Merker für Livebildausgabe
  498. blinken(); //lässt LED blinken
  499. return;
  500. }
  501. //konvertiert Foto und speichert es auf USB Stick
  502. void convert(){
  503. cout << "Speichern von Bild ..." << endl;
  504. std::string datname = gibDateiName(); //holen des Dateinamen
  505. std::string ordnerName = getFolderName(); //holen des Ordnernamen
  506. pruefeNewFolder(ordnerName);
  507. std::string comand = "convert bild.ppm /media/usb0/DCIM/"+ordnerName+ "/" + datname + ".jpg"; //Befehl zum konverieren, Ordnername und Dateiname werden hinzugefügt
  508. const char *cComand = comand.c_str(); //befehl zum ausführen in cons char
  509. system(cComand); //ausführen des Befehls
  510. std::string pfad = "fbi --noverbose -T 1 /media/usb0/DCIM/"+ordnerName+ "/" + datname + ".jpg &/"; //Befehl zum anzeigen das fertigen Bildes
  511. system("rm bild.ppm"); //löschen des temporären Bildes
  512. rueckschau(pfad);
  513. sleep(4); //für 4 Sekunden
  514. system("killall fbi"); //beendet Anzeigen des Bildes
  515. cout << "Abspeichern fertig" << endl;
  516. return;
  517. }
  518. //anzeigen des fertigen Bildes
  519. void rueckschau(string input)
  520. {
  521. const char *cComand = input.c_str();
  522. system(cComand);
  523. return;
  524. }
  525. //erstellt den Dateinamen aus der auktuellen Uhrzeit
  526. string gibDateiName()
  527. {
  528. time_t t = time(0);
  529. struct tm *aT = localtime(&t); //holen der aktuellen Zeit
  530. int istd = aT->tm_hour; //holen der Stunden
  531. int imin = aT->tm_min; //holen der Minuten
  532. int isec = aT->tm_sec; //holen der Sekunden
  533. std::string sstd = to_string(istd); //in String konvertieren
  534. std::string smin = to_string(imin);
  535. std::string ssec = to_string(isec);
  536. std::string datName = sstd + "-" + smin + "-" + ssec + "ActionPi"; //zu einem String zusammenfügen
  537. return datName;
  538. }
  539. //erstellen des neuen Ordners
  540. void creatNewFolder()
  541. {
  542. std::string folderName = getFolderName(); //holen des Ordnernamen
  543. std::string pfad = "/media/usb0/DCIM/" + folderName; //Pafd des Ordners
  544. bool exists = ordnerExistiert(pfad); //prüfen ob Ordner existiert
  545. if(exists == false) //wenn nein dann neuen Ordner erstellen
  546. {
  547. std::string comand = "mkdir " + pfad + ""; //Befehl zum erstellen des Ordners
  548. const char *cComand = comand.c_str();
  549. system(cComand);
  550. cout << "Ordner erstellt." << endl;
  551. }
  552. else //falls Ordner bereits vorhanden
  553. {
  554. cout << "Ordner existiert bereits." << endl;
  555. }
  556. return;
  557. }
  558. //erstellen des DCIM Ordners
  559. void creatDCIM()
  560. {
  561. std::string dcmiPfad = "/media/usb0/DCIM";
  562. bool dcmiExists = ordnerExistiert(dcmiPfad);
  563. if(dcmiExists == false){
  564. std::string dcmiComand = "mkdir /media/usb0/DCIM";
  565. const char *dcmicComand = dcmiComand.c_str();
  566. system(dcmicComand);
  567. cout << "DCIM Ordner erstellt." << endl;
  568. }
  569. else
  570. {
  571. cout << "DCIM existiert bereits." << endl;
  572. }
  573. }
  574. //prüft ob Ordner/DCIM bereits existiert
  575. bool ordnerExistiert(string pfad)
  576. {
  577. const char *cPfad = pfad.c_str();
  578. DIR *pDir; //Verzeichniss wird auf aktuellen Pfad gesetzt
  579. bool oExists = false;
  580. pDir = opendir(cPfad); //öffnen des Pfades
  581. if(pDir != NULL) //falls Ordner unter dem aktuellen Pfad vorhanden pDIR ungleich NULL
  582. {
  583. oExists = true;
  584. closedir(pDir); //schließen des Ordners
  585. }
  586. return oExists;
  587. }
  588. //prüft ob Ordner bereits existiert (wird gebraucht sollt die Kamera länger als 0.00 Uhr in Betrieb sein "0 Uhr Bug")
  589. void pruefeNewFolder(string input)
  590. {
  591. std::string pfad = "/media/usb0/DCIM/" + input;
  592. bool newFolderExists = ordnerExistiert(pfad);
  593. if(newFolderExists == false)
  594. {
  595. creatNewFolder();
  596. }
  597. else
  598. {
  599. }
  600. return;
  601. }
  602. //erstellt den Ordnernamen aus der auktuellen Uhrzeit (siehe gibDateiName)
  603. string getFolderName()
  604. {
  605. char *wtagName[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
  606. char *monatName[] = { "Dec", "Jan", "Feb", "Mar", "Apr", "May", "June", "July", "Aug", "Sept", "Oct", "Nov" };
  607. time_t t = time(0);
  608. struct tm *aT = localtime(&t);
  609. int tag = aT->tm_mday;
  610. int wtag = aT->tm_wday;
  611. int monat = aT->tm_mon;
  612. std::string stag = std::to_string(tag);
  613. std::string tagumonat = std::string() + wtagName[wtag] + "-" + monatName[monat];
  614. std::string folName = tagumonat + "-" + stag;
  615. return folName;
  616. }
  617. void initialisierung()
  618. {
  619. bcm2835_gpio_fsel(LED, BCM2835_GPIO_FSEL_OUTP); //Setze LED als Ausgang
  620. bcm2835_gpio_fsel(MODI, BCM2835_GPIO_FSEL_INPT); //Setze MODI als Eingang
  621. bcm2835_gpio_fsel(REC, BCM2835_GPIO_FSEL_INPT); //Setze REC als Eingang
  622. bcm2835_gpio_fsel(Ex1, BCM2835_GPIO_FSEL_INPT); //Setze Ex1 als Eingang
  623. bcm2835_gpio_fsel(Ex2, BCM2835_GPIO_FSEL_INPT); //Setze Ex2 als Eingang
  624. bcm2835_gpio_fsel(Ex3, BCM2835_GPIO_FSEL_INPT); //Setze Ex3 als Eingang
  625. bcm2835_gpio_set_pud(MODI, BCM2835_GPIO_PUD_UP); //Schalter als Öffner
  626. bcm2835_gpio_set_pud(REC, BCM2835_GPIO_PUD_UP); //Schalter als Öffner
  627. bcm2835_gpio_set_pud(Ex1, BCM2835_GPIO_PUD_UP); //Schalter als Öffner
  628. bcm2835_gpio_set_pud(Ex2, BCM2835_GPIO_PUD_UP); //Schalter als Öffner
  629. bcm2835_gpio_set_pud(Ex3, BCM2835_GPIO_PUD_UP); //Schalter als Öffner
  630. return;
  631. }
  632. //liest die Schalterstellung von MODI ein
  633. int getMODI()
  634. {
  635. valMODI = !bcm2835_gpio_lev(MODI);
  636. return valMODI;
  637. }
  638. //liest die Schalterstellung von REC ein
  639. int getREC()
  640. {
  641. valREC = !bcm2835_gpio_lev(REC);
  642. return valREC;
  643. }
  644. //liest die Schalterstellung von Ex1 ein
  645. int getEx1()
  646. {
  647. valEx1 = !bcm2835_gpio_lev(Ex1);
  648. return valEx1;
  649. }
  650. //liest die Schalterstellung von Ex2 ein
  651. int getEx2()
  652. {
  653. valEx2 = !bcm2835_gpio_lev(Ex2);
  654. return valEx2;
  655. }
  656. //liest die Schalterstellung von Ex3 ein
  657. int getEx3()
  658. {
  659. valEx3 = !bcm2835_gpio_lev(Ex3);
  660. return valEx3;
  661. }
  662. //lässt die Status-LED 10 mal blinken
  663. void blinken()
  664. {
  665. for(int i=0; i<10; i++)
  666. {
  667. bcm2835_gpio_set(LED);
  668. delay(100);
  669. bcm2835_gpio_clr(LED);
  670. delay(50);
  671. }
  672. return;
  673. }
  674. //Herunterfahren der Kamera bei gleizeitgem drücken des REC Knopfes und der mittleren Funktionstaste
  675. void herunterfahren()
  676. {
  677. if(getREC() && getEx2())
  678. {
  679. cout << "Herunterfahren" << endl;
  680. system("killall raspivid");
  681. blinken();
  682. system("sudo shutdown -h now ");
  683. }
  684. return;
  685. }
  686. //beenden des Kameraprogramms bei gleichzeitigen drücken der äußeren Funktionstasten
  687. void programmBeenden()
  688. {
  689. if(getEx3() && getEx1())
  690. {
  691. aktiv = false; // Merker für while-Schleife
  692. system("killall raspivid");
  693. blinken();
  694. }
  695. return;
  696. }