Kopter weg..... wie wiederfinden??? (Projekt)

    • Hallo Cynob,
      Ich glaube nach meiner Meinung nach ist aller 30 ms zu schnell.Brauchst Du hier eine Verfolgung des Fluges,wie es bei Flytrex der fall ist.
      Oder soll er bei Verlust des Kopters den Standort des Absturzes.Also das wiederfinden des Kopters angezeigt werden.So wie das Forum in der Überschrift lautet.
      Kopter weg ....wieder finden.Dann reicht ja auch zum Beispiel eine Übertragung von 5 Minuten.Wichtig ist ja den Endpunkt zu finden wo er verschollen ist.
      Aller 30 ms den Standort zu lokalisieren hat auch seine Vorteile ,es kann vielleicht leichter Verfolgt werden.
      Aber Cynob du bekommst das hin und ich freue mich schon auf ein Super Ergebnis.

      Mit besten Gruß
      Hans-J.
    • Die Kiste soll ja nicht alle 30ms senden sondern nur intern Wegpunkte setzen - sobald die Liste von x Stück voll ist wird wieder von vorne angefangen und überschrieben.
      Wenn man dann das auslesen mit der SMS triggert werden die letzten paar meter wegstrecke somit angezeigt.
      Kommt halt auch drauf an wie gut das GPS geht, also ich mein wenn das aufm Kopf liegt und trotzdem einen fix bekommen sollte braucht man das ja alles nicht.

      So schönen Tag mal noch
      Gruß Cynob
    • Klasse Projekt. Das GPS Modul wird aber allenfalls, wenn es schnell ist, mit 5 HZ ein Positionsupdate liefern ! Sprich alle 200 ms. Möglicherweise auch nur 1 HZ.

      Ich habe einen ähnlichen Finder, allerdings nicht mit GSM Modul sondern mit LoRa-433 MHZ Übertragung ALLE 15 Sekunden.
      Die Beschleunigungssensoren als Indikator für "liegt irgendwo herum" halte ich für sehr problematisch, wenn der Kopter bei nur leichtem Wind in einem Ast im Baum hängt. Bei etwas Wind und Wackeln des Astes hast Du hinterher nie eine SMS. Ich würde den SMS-Empfang auswerten: Wird eine SMS mit einem "Passwort" empfangen, dann sende die zuletzt empfangene (und im Arduino gespeicherte) Position . Die Position sollte unbedingt gespeichert bleiben, falls der Kopter beim Absturz in einen Kellerschacht fällt und dort keinen GPS-Empfang mehr hat, dann hast Du mindestens noch den letzten aus der Luft über dem Schacht ;)

      Viele Erfolg weiter, klasse Projekt.

      Gruß Rolf
    • So mal was erfreuliches :) das Geraffel mit dem GPS und dem Sim Modul spricht schonmal an. (Das GPS Modul hat ein wenig Nachhilfe gebraucht aber da will ich mich jetzt nicht drüber aufregen)
      Jetzt hab ich mir den Softwareaufbau schon so halb überlegt...
      Wenn das GPS erstmal einen Fix hat kann man recht zuverlässig wenn auch nicht schnell die Geokoordinaten sowie die Höhe ( und noch mehr Zeug was wir nicht brauchen) auslesen.
      Ich hab das Teil jetzt zum Test auf dem Balkon liegen gehabt mit doch recht eingeschränkter Sicht zum Himmel. Die Ausgabewerte variieren im Nachkommastellenbereich - das macht aber bei Google Maps keinen Unterschied von der Standorterkennung.

      Beim Sim Modul wollte gestern Abend im ersten Anlauf das Teil nicht mit egal welcher lib zusammenarbeiten - lässt sich allerdings über AT Befehle steuern. - Da muss ich nochmal schauen ob was geht oder selbst was zaubern ( ist auch nicht so "hä" wie der NMEA stream vom GPS):D

      Alles in allem hab ich irgendwie zu wenig Freizeit nur mal so als Anmerkung :D
    • Guten morgen :o

      Ich hab gestern mal damit Zeit verbracht ein erstes Programm für den Arduino zu schreiben. Es läuft noch nicht wirklich rund - zum einen hatte ich gestern abend zwar nen GPS Fix und die Daten auch schön angezeigt bekommen - allerdings hatte ich einige Probleme die Werte welche als float vom GPS kommen sauber in ein char array zu konvertieren. Das hab ich dann zuletzt (hoffentlich) mit "dtostrf" gelöst, denn heute morgen als ich das Gerät wieder angeschlossen hatte und auf den Balkon legte bekam ich laut meiner Software keinen Fix - das GPS Modul blinkt aber fröhlich das alles OK wäre und ein erster Test zeigt das es auch Daten liefert.
      So damit ich mich an so nem schönen morgen jetzt nicht ärgere hab ich mich dazu entschlossen das Ding mal in die Ecke zu legen und hier zu schreiben ( so zum Ausgleich).



      C-Quellcode

      1. #include "Arduino.h"
      2. #include <Sim800l.h>
      3. #include <TinyGPS++.h>
      4. #include <SoftwareSerial.h>
      5. //*******************************************************************************************************************
      6. //Einstellungen für debug
      7. static boolean debug = true;
      8. static const uint32_t serialBaud = 9600;
      9. //Einstellungen für das GPS
      10. static const int GPS_RXPin = 4, GPS_TXPin = 3;
      11. static const uint32_t GPSBaud = 9600;
      12. //Einstellungen für das Sim800L Modul
      13. static String SMSpassword = "1234567890"; // Passwort auf das reagiert wird
      14. static String sendSMSto = "+4917612345678"; // Nummer an welche gesendet werden soll
      15. long interval = 30000; // interval Abfrage Geschwindigkeit (30 Sekunden = 30000)
      16. //static const int SIM_RXPin = 4, SIM_TXPin = 3; setzen in sim800l.h
      17. //static const uint32_t SIMBaud = 2400; setzen in sim800l.cpp Zeile 39
      18. //*******************************************************************************************************************
      19. // The TinyGPS++ object
      20. TinyGPSPlus gps;
      21. // The serial connection to the GPS device
      22. SoftwareSerial GPSserial(GPS_RXPin, GPS_TXPin);
      23. // Variables for GPS
      24. volatile float GPSlat[3];
      25. volatile float GPSlong[3];
      26. volatile float GPSalt[3];
      27. int GPScount;
      28. int GPSmaxCount = 3;
      29. // The Sim800l object
      30. Sim800l SIMcard;
      31. // Variables for SIM
      32. String incommingSMStext; // to storage the text of the sms
      33. uint8_t incSMSindex = 1; // to indicate the message to read.
      34. char generateText[155];
      35. bool SMSerror; //to catch the response of sendSms
      36. long previousMillis = 0; //timer for get sms
      37. //*******************************************************************************************************************
      38. void setup()
      39. {
      40. if (debug == true)Serial.begin(serialBaud);
      41. SIMcard.begin();
      42. //clean up Sim Card
      43. SIMcard.delAllSms();
      44. if (debug == true)Serial.println("...start testing....");
      45. GPSserial.begin(GPSBaud);
      46. }
      47. //*******************************************************************************************************************
      48. void loop()
      49. {
      50. //Add your repeated code here
      51. for (int GPScount = 0; GPScount < GPSmaxCount; GPScount++) {
      52. if (debug == true)Serial.println("...saving GPS data starting....");
      53. saveGPSdata(gps.location.lat(), gps.location.isValid(), GPScount, 1);
      54. saveGPSdata(gps.location.lng(), gps.location.isValid(), GPScount, 2);
      55. saveGPSdata(gps.altitude.meters(), gps.altitude.isValid(), GPScount, 3);
      56. if (debug == true){
      57. Serial.print("...saving GPS data done...count: ");
      58. Serial.println(GPScount);
      59. }
      60. }
      61. unsigned long currentMillis = millis();
      62. if(currentMillis - previousMillis > interval) {
      63. previousMillis = currentMillis;
      64. SIMcard.begin();
      65. //GPSsmartDelay(1000);
      66. checkforsms();
      67. GPSserial.begin(GPSBaud);
      68. }
      69. GPSsmartDelay(1000);
      70. }
      71. //*******************************************************************************************************************
      72. void saveGPSdata(float val, bool valid, int GPScount, int type)
      73. {
      74. if (!valid)
      75. {
      76. if (debug == true)Serial.println("no GPS Fix yet...");
      77. }
      78. else
      79. {
      80. switch (type) {
      81. case 1:
      82. GPSlat[GPScount] = val;
      83. if (debug == true){
      84. Serial.print("lat: ");
      85. Serial.println(GPSlat[GPScount], 15);
      86. }
      87. break;
      88. case 2:
      89. GPSlong[GPScount] = val;
      90. if (debug == true){
      91. Serial.print("long: ");
      92. Serial.println(GPSlong[GPScount], 15);
      93. }
      94. break;
      95. case 3:
      96. GPSalt[GPScount] = val;
      97. if (debug == true){
      98. Serial.print("alt: ");
      99. Serial.println(GPSalt[GPScount], 15);
      100. }
      101. break;
      102. }
      103. }
      104. GPSsmartDelay(0);
      105. }
      106. void checkforsms()
      107. {
      108. if (debug == true)Serial.println("checkforsms");
      109. incommingSMStext=SIMcard.readSms(incSMSindex);
      110. if (debug == true){
      111. Serial.println("sms------read for debug");
      112. Serial.println(incommingSMStext);
      113. }
      114. if(incommingSMStext.indexOf(SMSpassword) > 4) {
      115. //send sms back
      116. if (debug == true)Serial.println("sms GIVE ANSWER");
      117. sendLocation();
      118. }
      119. //debugsms();
      120. }
      121. void debugsms() {
      122. Serial.println("sms GIVE ANSWER......Debug");
      123. GPSsmartDelay(1000);
      124. sendLocation();
      125. }
      126. void sendLocation()
      127. {
      128. if (debug == true)Serial.println("sms gen buffer");
      129. char namelat[7] = " lat.";
      130. char namelong[8] = " long.";
      131. char namealt[7] = " alt.";
      132. char space[5] = "---";
      133. char bufferGPSlat01[30], bufferGPSlong01[30], bufferGPSalt01[16];
      134. if (debug == true)Serial.println("sms filling");
      135. dtostrf(GPSlat[1], 15, 12, bufferGPSlat01);
      136. dtostrf(GPSlong[1], 15, 12, bufferGPSlong01);
      137. dtostrf(GPSalt[1], 15, 12, bufferGPSalt01);
      138. if (debug == true)
      139. {
      140. Serial.print(bufferGPSlat01);
      141. Serial.println();
      142. Serial.print(bufferGPSlong01);
      143. Serial.println();
      144. Serial.print(bufferGPSalt01);
      145. }
      146. generateText[0] = 0;
      147. strcat(generateText, namelat);
      148. strcat(generateText, bufferGPSlat01);
      149. strcat(generateText, namelong);
      150. strcat(generateText, bufferGPSlong01);
      151. strcat(generateText, namealt);
      152. strcat(generateText, bufferGPSalt01);
      153. if (debug == true)Serial.println(generateText);
      154. // convert phone number to char array
      155. char PhoneNumber[sendSMSto.length()+1];
      156. sendSMSto.toCharArray(PhoneNumber,sendSMSto.length()+1);
      157. // send sms
      158. SMSerror=SIMcard.sendSms(PhoneNumber,generateText);
      159. // wait 3 sec
      160. GPSsmartDelay(1000);
      161. // resend if not
      162. if (SMSerror)
      163. {
      164. SIMcard.delAllSms();
      165. }
      166. else
      167. {
      168. SMSerror=SIMcard.sendSms(PhoneNumber,generateText);
      169. GPSsmartDelay(1000);
      170. }
      171. }
      172. // This custom version of delay() ensures that the gps object
      173. // is being "fed".
      174. void GPSsmartDelay(unsigned long ms)
      175. {
      176. unsigned long start = millis();
      177. do
      178. {
      179. while (GPSserial.available())
      180. gps.encode(GPSserial.read());
      181. } while (millis() - start < ms);
      182. }
      Alles anzeigen


      Was das Stück Software nun macht:
      Erstmal beim Start wird der SMS Speicher der Sim Karte geleert. Danach startet die Verbindung zum GPS und lädt immer wieder jeweils 3 Sätze von lat/long/alt welche in Variablen gespeichert werden.
      Alle 30 Sekunden wird dieser Vorgang unterbrochen und abgefragt ob eine neue SMS auf dem ersten Platz der Sim Karte liegt. Wenn dem nicht so ist wird wieder mit dem GPS weitergemacht.
      Falls eine SMS angekommen so wie das Passwort in dieser korrekt ist wird der erste Datensatz des GPS in eine Nachricht verpackt und diese an die oben im Programm angegebene Nummer gesendet.
      Da fällt mir grad auf das dort noch das "error handling" fehlt ( Baustellen ohne Ende :D )


      Für Verbesserungsvorschläge bin ich immer offen!

      ToDo:
      - Erstmal das Teil wieder überreden mit mir zusammenzuarbeiten :D
      - Anstelle 3 GPS Datensätze vll 6 speichern um daraus eine Vorraussage der Genauigkeit der Daten errechnen zu können
      - Anstelle der festen Nummer für die SMS Antwort die Zahlen aus der angekommenen SMS auslesen.
      - LED auf dem Arduino für ein wenig Status Anzeige verwenden
      - Batterie Status auslesen
      Dann fallen mir noch so Dinge wie ein Piepser ein aber ich werde froh sein wenns erstmal so sauber läuft.

      Gruß Cynob
    • Ok mal was neues:
      "
      ToDo:
      - Erstmal das Teil wieder überreden mit mir zusammenzuarbeiten [Check]
      - Anstelle 3 GPS Datensätze vll 6 speichern um daraus eine Vorraussage der Genauigkeit der Daten errechnen zu können
      - Anstelle der festen Nummer für die SMS Antwort die Zahlen aus der angekommenen SMS auslesen. [Check]
      - LED auf dem Arduino für ein wenig Status Anzeige verwenden [Check]
      - Batterie Status auslesen [Check]
      "

      So eigentlich kann das Ding jetzt alles denk ich mal. Das mit der Genauigkeit kann man sich schenken.... die NMEA Daten pro Satelit variieren zwar aber in so einem geringen Bereich das es für Google Maps unnötig ist. Google Maps arbeitet z.B. mit 6 Nachkommastellen, also brauchen wir da nicht wirklich mehr, das wär dann nur zu statistischen Zwecken denk ich.

      So den Code für den Arduino hab ich nochmal überarbeitet jetzt sollte er ein wenig "flüssiger" laufen. Das Ding ist das das GPS Modul echt ne Krücke darstellt und wie weiter vorne im Thread schonmal angemerkt so vielleicht alle 0,5 bis 1 Sekunde ne valide Geokoordinate ausgegeben wird. Die Aufzeichnung der drei Datensätze kostet somit Zeit. Jetzt die Frage an alle die hier mitlesen > soll man die Genauigkeit welche von GMaps nicht erfasst wird noch berrechnen und mitsenden oder das einfach bleiben lassen? Im Augenblick speichert der Code 3 Datensätze - verwendet aber immer nur den zuletzt aufgezeichneten.

      So nun mal die Technischen Neuerungen ( auch gern changelog genannt):

      - Es wird nicht mehr die erste von drei sondern immer die zuletzt aufgezeichnete Geokoordinate zurückgesendet.
      - loop neu gestaltet um das ganze ein wenig dynamischer zu bekommen
      - Volt der Batterie werden mit zurück geschickt. Die Anzeige lässt sich über die Einstellungen kallibrieren.
      - Led auf dem Arduino blinkt nun je nach Status.
      - Es wird jetzt auf jedes Handy mit dem richtigen Passwort in der SMS geantwortet ( nicht wie ein fest vorgegebene Nummer vorher)

      Dazu könnte man jetzt noch nen Piepser bauen um das Fluggerät in näherem Umfeld zu finden welchen man über sms triggern könnte - sollte man das noch mit reinbasteln?

      Soweit so gut
      Gruß Cynob
    • Hier mal die Schaltkreise um mit dem Arduino das GPS Modul, GSM Modul sowie die Spannungsüberwachung

      Wobei beim Arduino Pro Mini kann man theoretisch jeden Pin für Softserial gebrauchen - man muss den Code nur dementsprechend anpassen.

      Schaltung für SIM800l Modul:

      Brainfuck-Quellcode

      1. SIM800l Pin GND o---|------- GND
      2. .-. ___
      3. | | 0,4KOhm -|___|-------o Arduino Pin 7
      4. | | | 2,2KOhm
      5. '-' |
      6. SIM800l Pin RX o---|---------------'
      7. ___
      8. --------|___|-------o Arduino Pin 8
      9. | 1KOhm
      10. |
      11. SIM800l Pin TX o-------------|
      12. ___
      13. -----|___|-------o Arduino Pin 9
      14. | 1KOhm
      15. ---
      16. SIM800l Pin RST o---------------/ v--------o GND
      17. BC337 NPN
      18. SIM800l Pin +4,2 o--------------------------o Lipo +4,2 Volt
      Alles anzeigen



      Schaltung für GPS:

      Brainfuck-Quellcode

      1. UBLOX NEO 6M GND o ------------------------ GND
      2. UBLOX NEO 6M RX o --------------------------------------------------.
      3. .---- o Arduino Pin 3
      4. UBLOX NEO 6M TX o -----------------------------------------------.
      5. |
      6. '--------o Arduino Pin 4
      7. UBLOX NEO 6M VCC o ---------------------------------.
      8. |
      9. |
      10. |
      11. |
      12. |
      13. |
      14. |
      15. |
      16. |
      17. '-------------------o Arduino VCC 3,3V+
      Alles anzeigen



      Schaltung für Spannungsmessung des Lipos:

      Brainfuck-Quellcode

      1. Lipo 4,2V + o -----------------------------.
      2. | 1KOhm
      3. | ___
      4. --|___|---------- o Arduino Pin A0
      5. |
      6. .-.
      7. | |
      8. | | 0,4KOhm
      9. '-'
      10. |
      11. Lipo minus - o -----------------------------------------'
      Alles anzeigen



      So der aktuelle Code sieht so aus:
      Wenn jemand die bearbeiteten Bibliotheken möchte schnür ich dann gern ein Paket mit allem drin.

      Arduino Code:

      C-Quellcode

      1. #include "Arduino.h"
      2. #include <stdio.h>
      3. #include <string.h>
      4. #include <Sim800l.h>
      5. #include <TinyGPS++.h>
      6. #include <SoftwareSerial.h>
      7. //*******************************************************************************************************************
      8. //#################### Einstellungen ####################
      9. //Einstellungen für debug
      10. static boolean debug = true;
      11. static const uint32_t serialBaud = 9600;
      12. //Einstellungen für das GPS
      13. static const int GPS_RXPin = 4, GPS_TXPin = 3;
      14. static const uint32_t GPSBaud = 9600;
      15. //Einstellungen für das Sim800L Modul
      16. static String SMSpassword = "1234567890"; // Passwort auf das reagiert wird
      17. unsigned long smsinterval = 10000; // interval Abfrage Geschwindigkeit (30 Sekunden = 30000)
      18. //static const int SIM_RXPin = 7, SIM_TXPin = 8; setzen in sim800l.h
      19. //static const uint32_t SIMBaud = 2400; setzen in sim800l.cpp Zeile 39
      20. //Einstellungen für LED
      21. const int ledPin = 13; // Led Pin 13 = board LED
      22. unsigned long ledinterval = 100; // blink on/off in ms
      23. //Einstellungen für Spannungsüberwachung
      24. unsigned long pwrinterval = 5000; // Interval in welcher die Spannung abgefragt wird
      25. float pwrCalibrationVolt = 4.16; // Volt am Lipo gemessen
      26. float pwrCalibrationdivider = 360; // wird beim debud durchlauf angezeigt
      27. //*******************************************************************************************************************
      28. //#################### internes Zeugs ##############################
      29. // The TinyGPS++ object
      30. TinyGPSPlus gps;
      31. // The serial connection to the GPS device
      32. SoftwareSerial GPSserial(GPS_RXPin, GPS_TXPin);
      33. // Variables for GPS
      34. volatile double GPSlat[3];
      35. volatile double GPSlong[3];
      36. volatile double GPSalt[3];
      37. int GPScount;
      38. int GPSmaxCount = 3;
      39. // The Sim800l object
      40. Sim800l SIMcard;
      41. // Variables for SIM
      42. String incommingSMStext; // to storage the text of the sms
      43. uint8_t incSMSindex = 1; // to indicate the message to read.
      44. char generateText[155]; // the char array for the answer message
      45. bool SMSerror; //to catch the response of sendSms
      46. unsigned long smspreviousMillis = 0; //timer for get sms
      47. // LED object
      48. int ledState = LOW; // ledState used to set the LED
      49. long ledpreviousMillis = 0; // will store last time LED was updated
      50. // Powercheck object
      51. long pwrpreviousMillis = 0; // will store last time LED was updated
      52. volatile float voltage;
      53. //*******************************************************************************************************************
      54. //#################### setup & loop ##############################
      55. void setup()
      56. {
      57. pinMode(ledPin, OUTPUT);
      58. if (debug == true)Serial.begin(serialBaud);
      59. /*
      60. SIMcard.begin();
      61. //clean up Sim Card
      62. SIMcard.delAllSms();
      63. */
      64. if (debug == true)Serial.println("...start testing....");
      65. GPSserial.begin(GPSBaud);
      66. GPSsmartDelay(2000);
      67. }
      68. void loop()
      69. {
      70. LEDblink();
      71. GPScount = 0;
      72. generateGPSdata(GPScount);
      73. GPSsmartDelay(100);
      74. testsimcard();
      75. LEDblink();
      76. GPScount = 1;
      77. generateGPSdata(GPScount);
      78. GPSsmartDelay(100);
      79. LEDblink();
      80. GPScount = 2;
      81. generateGPSdata(GPScount);
      82. GPSsmartDelay(60);
      83. checkforVoltage();
      84. GPSsmartDelay(20);
      85. }
      86. //*******************************************************************************************************************
      87. //#################### GPS ##############################
      88. void generateGPSdata(int GPScount)
      89. {
      90. if (debug == true)Serial.println("...saving GPS data starting....");
      91. saveGPSdata(gps.location.lat(), gps.location.isValid(), GPScount, 1);
      92. saveGPSdata(gps.location.lng(), gps.location.isValid(), GPScount, 2);
      93. saveGPSdata(gps.altitude.meters(), gps.altitude.isValid(), GPScount, 3);
      94. if (debug == true){
      95. Serial.print("...saving GPS data done...count: ");
      96. Serial.println(GPScount);
      97. }
      98. }
      99. void saveGPSdata(float val, bool valid, int GPScount, int type)
      100. {
      101. if (!valid)
      102. {
      103. if (debug == true)Serial.println("no GPS Fix yet...");
      104. }
      105. else
      106. {
      107. switch (type) {
      108. case 1:
      109. GPSlat[GPScount] = val;
      110. if (debug == true){
      111. Serial.print("lat: ");
      112. Serial.println(GPSlat[GPScount], 15);
      113. }
      114. break;
      115. case 2:
      116. GPSlong[GPScount] = val;
      117. if (debug == true){
      118. Serial.print("long: ");
      119. Serial.println(GPSlong[GPScount], 15);
      120. }
      121. break;
      122. case 3:
      123. GPSalt[GPScount] = val;
      124. if (debug == true){
      125. Serial.print("alt: ");
      126. Serial.println(GPSalt[GPScount], 15);
      127. }
      128. break;
      129. }
      130. }
      131. GPSsmartDelay(0);
      132. }
      133. //*******************************************************************************************************************
      134. //#################### SIM800L ##############################
      135. void testsimcard()
      136. {
      137. unsigned long currentMillis = millis();
      138. if(currentMillis - smspreviousMillis > smsinterval) {
      139. smspreviousMillis = currentMillis;
      140. SIMcard.begin();
      141. checkforsms();
      142. GPSserial.begin(GPSBaud);
      143. }
      144. }
      145. void checkforsms()
      146. {
      147. if (debug == true)Serial.println("checkforsms");
      148. incommingSMStext=SIMcard.readSms(incSMSindex);
      149. if (debug == true){
      150. Serial.println("sms------read for debug");
      151. Serial.println(incommingSMStext);
      152. }
      153. if(incommingSMStext.indexOf(SMSpassword) > 4) {
      154. //send sms back
      155. if (debug == true)Serial.println("sms GIVE ANSWER");
      156. sendLocation();
      157. }
      158. //debugsms();
      159. }
      160. void debugsms() {
      161. Serial.println("sms GIVE ANSWER......Debug");
      162. GPSsmartDelay(1000);
      163. sendLocation();
      164. }
      165. void sendLocation()
      166. {
      167. if (debug == true)Serial.println("sms gen buffer");
      168. char namelat[7] = " lat.";
      169. char namelong[8] = " long.";
      170. char namealt[7] = " alt.";
      171. char namebat[7] = " Bat.";
      172. char bufferGPSlat01[40], bufferGPSlong01[40], bufferGPSalt01[40], bufferBattery[10];
      173. if (debug == true)Serial.println("sms filling");
      174. // convert geo data to char
      175. dtostrf(GPSlat[GPScount], 11, 7, bufferGPSlat01);
      176. dtostrf(GPSlong[GPScount], 10, 7, bufferGPSlong01);
      177. dtostrf(GPSalt[GPScount], 5, 2, bufferGPSalt01);
      178. // convert battery data to char
      179. dtostrf(voltage, 3, 2, bufferBattery);
      180. if (debug == true)
      181. {
      182. Serial.print(bufferGPSlat01);
      183. Serial.println();
      184. Serial.print(bufferGPSlong01);
      185. Serial.println();
      186. Serial.print(bufferGPSalt01);
      187. Serial.println();
      188. }
      189. // generate text for geo
      190. generateText[0] = 0;
      191. strcat(generateText, namelat);
      192. strcat(generateText, bufferGPSlat01);
      193. strcat(generateText, namelong);
      194. strcat(generateText, bufferGPSlong01);
      195. strcat(generateText, namealt);
      196. strcat(generateText, bufferGPSalt01);
      197. // append for battery
      198. strcat(generateText, namebat);
      199. strcat(generateText, bufferBattery);
      200. GPSsmartDelay(50);
      201. if (debug == true)Serial.println(generateText);
      202. // convert phone number to char array
      203. String incommingSMSNumber=SIMcard.getNumberSms(incSMSindex);
      204. char PhoneNumber[incommingSMSNumber.length()+1];
      205. incommingSMSNumber.toCharArray(PhoneNumber,incommingSMSNumber.length()+1);
      206. GPSsmartDelay(50);
      207. if (debug == true)Serial.println(PhoneNumber);
      208. // send sms
      209. SMSerror=SIMcard.sendSms(PhoneNumber,generateText);
      210. //SMSerror=true;
      211. // wait some time
      212. GPSsmartDelay(1000);
      213. // resend if not
      214. if (SMSerror)
      215. {
      216. SIMcard.delAllSms();
      217. }
      218. else
      219. {
      220. //SMSerror=SIMcard.sendSms(PhoneNumber,generateText);
      221. GPSsmartDelay(1000);
      222. SIMcard.delAllSms();
      223. }
      224. }
      225. //*******************************************************************************************************************
      226. //#################### LED ##############################
      227. void LEDblink()
      228. {
      229. unsigned long currentMillis = millis();
      230. if(currentMillis - ledpreviousMillis > ledinterval) {
      231. ledpreviousMillis = currentMillis;
      232. if (ledState == LOW)
      233. ledState = HIGH;
      234. else
      235. ledState = LOW;
      236. digitalWrite(ledPin, ledState);
      237. }
      238. }
      239. //*******************************************************************************************************************
      240. //#################### Spannungsüberwachung ##############################
      241. void checkforVoltage()
      242. {
      243. unsigned long currentMillis = millis();
      244. if(currentMillis - pwrpreviousMillis > pwrinterval) {
      245. if (debug == true)Serial.println("reading voltage");
      246. int sensorValue = analogRead(A0);
      247. voltage = sensorValue * (pwrCalibrationVolt / pwrCalibrationdivider);
      248. if (debug == true){
      249. Serial.print("Sensor Val.: ");
      250. Serial.println(sensorValue);
      251. Serial.print("Saved Val.: ");
      252. Serial.println(voltage);
      253. }
      254. }
      255. }
      256. //*******************************************************************************************************************
      257. //#################### Helferlein ##############################
      258. // This custom version of delay() ensures that the gps object
      259. // is being "fed".
      260. void GPSsmartDelay(unsigned long ms)
      261. {
      262. unsigned long start = millis();
      263. do
      264. {
      265. while (GPSserial.available())
      266. gps.encode(GPSserial.read());
      267. } while (millis() - start < ms);
      268. }
      Alles anzeigen


      So long Cynob ;)