SIM800 GSM: Welche Library für Arduino?

[Chris J. (Gast)]

Hallo,

um ein GSM Modul SIM800 mit einem Ardu pro Mini zu betreiben suche ich 
eine Library, damit ich solche Sachen wie AT-String-Parser nicht selbst 
schreiben muss. Mir reicht schon den Parser für meine eigenen sms 
schreiben zu müssen mit denen das Gerät gesteuert wird, habe leider eine 
innere Abwehr gegen Stringverarbeitung bei C. Es gibt da wohl etliches 
Libs wie ich inzwischen weiss.

Ich brauche auf jeden Fall die Abfrage des Batteriestatus und die 
Möglichkeit die RTC abzufragen, sowie alle sms Funktionen. Die Uhrzeit 
wird wohl bei der Netzeinwahl an das Modul übertragen und kann im uC 
verwendet werden. Bisher keine Lib gefunden, die alles drin hat.

Habt ihr da eine Empfehlung welche schlanke Lib ich einbinden kann? 30kb 
sind verfügbar, sollte also keine so aufgeblähte wie die FONA von 
Adafruit sein,

Gruss,
Christian

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

Ich hab mir sowas für meine Alarmsau gerade in Assembler selbst 
gebastelt. So schwer ist es nicht.

Die Abfrage der Uhrzeit (das Modul bekommt die Uhrzeit nach der Einwahl 
aus dem Netz) und des Batteriestatus ist ein einfaches AT-Kommando 
(AT+CCLK und AT+CBC). Das braucht man nur senden und das Modul antwortet 
entsprechend.

(Den Batteriestatus brauche ich bei meiner AlarmSau nicht, das Modul 
läuft mit einem 4V Regler aus den 5V, die widerum aus den 12V eines 
Bleiakkus gespeist werden, der aus dem 230V nachgeladen wird.)

[Stefan F. (Gast)]

Mehr als die String Klasse oder die entsprechenden Funktionen der 
avr-libc 
(https://www.nongnu.org/avr-libc/user-manual/group__avr__string.html) 
braucht man dazu nicht.

[Chris J. (Gast)]

Hi,

mit Arduino dreh ich noch ab, ohne gescheiten Debugger (man reiche mir 
meine Cortexe wieder....). Gerade mit Strings wo man tausendmal was 
ausprobieren muss.

Die erste Lib von einem Türken namens Arslan lief direkt schon nicht. 
Oder nur halb. Da man nicht weiss, was da genau nicht läuft schreibe ich 
es jetzt slebst.

Aber selbst hier scheitert es schon, weil ich nicht genau weiss, was da 
exakt rauskommt, selbst wenn da

AT
OK

Ist das nun AT\r\nOK oder AT\r\nOK\r\n oder... oder oder...


auf dem Serial Monitor steht.... grrrrr.....

/* Ueberprüft, ob das SIM800 Modul antwortet */
int SIM800_WaitForReady()
{
  char response[32];
  char* i = response;
  
  serialSIM800.println(F("AT"));
  delay(200);
  
   while (serialSIM800.available() )
   {
    *i = serialSIM800.read();
    Serial.write(*(i++));
   }
   *i = '\0';
   
   i = response;
   if (strcmp(i,"AT OK")!= 0)
    Serial.println("Antwort falsch!");
  else 
    Serial.println("Antwort richtig!");

[derjaeger (Gast)]

AT\r\nOK\r\n hört sich richtig an.

Kopier doch die Antwort in NPP rein und lass dir \r\n anzeigen:

https://superuser.com/questions/409919/cr-and-lf-characters-shown-at-the-end-of-each-line-in-notepad

[derjaeger (Gast)]

[quote]mit Arduino dreh ich noch ab, ohne gescheiten Debugger[/quote]

Ich hab praktisch auf einem Arduino eine ganze Kommunikation mit einem 
ESP8266 hingekriegt nur mit dem Serial Monitor als Hilfe :-) So schwer 
ist das nicht.

[Chris J. (Gast)]

derjaeger schrieb:
> Ich hab praktisch auf einem Arduino eine ganze Kommunikation mit einem
> ESP8266 hingekriegt nur mit dem Serial Monitor als Hilfe :-) So schwer
> ist das nicht.

Ja, als ich anfing auf dem Z80 gabs nur ne rote LED als Debugger, und 
nen Taster wo man Single Steppen konnte.... so 1984 war das als Asm 
Progis och per Hand umgerechnet wurden in ner Tabelle :-(((((

[derjaeger (Gast)]

Ich fand das beim Arduino super .. ich musste mich nicht um Strings 
kümmern oder um eine Serial Kommunikation .. alles war da ich musste nur 
die Befehle verschicken und vergleichen.

Warum benutzt du char* ? Nimm doch String ...

Mach doch folgendes ..

String response = serialSIM800.read();
if(response == "OK\r\n") 
....

[Chris J. (Gast)]

derjaeger schrieb:
> Nimm doch String ...

Bei "String" behauptet man dass das Probleme geben könnte in einem Forum 
wo ich grad guckte.... ich nehm lieber das was ich verstehe und sehen 
kann.

.read liest nur ein zeichen übrigens und .readstring finde ich nicht 
dokumentiert.


Also auf die Altmodische...

 p = response;
   while (*p) {
     Serial.print(*(p++),HEX);
     Serial.println(" ");
   }

[derjaeger (Gast)]

Ich bin auf einem Arduino Nano und ESP8266 prima mit String klar 
gekommen, das hat die gleiche AT-Syntax wie dein Modul.

Alles ich praktisch immer gemacht habe waren nur die folgenden 3 
Befehle:

Serial.println("...") // At befehl senden
Serial.read() // Antwort einlesen
if(response == "") // Antwort auswerten

[Chris J. (Gast)]

Ok, jedenfalls sehe ich grad, dass der SIM800  /r/r/n ausgibt, sehr 
seltsam... 0x0d und 0x0d in der Ausgabe.

[derjaeger (Gast)]

Sorry ich meinte readBytes ...

https://www.arduino.cc/en/Reference/StreamReadBytes

Ich glaub ich hab dem einen char* Puffer übergeben und dann nach der 
eingelesenen Antwort einfach gesagt:

String response = String(buffer);

Vorher muss man mit setTimeout() sagen wann readBytes() aufhören soll 
wenn keine Bytes mehr reinkommen

[Chris J. (Gast)]

Jedenfalls klappt das jetzt, sehr seltsam.... man beachte das strcmp....
das jetzt noch eine do while rein und ein timeout mit millies und dann 
müsste das spielen... und ich verstehe es auch noch.

/* Ueberprüft, ob das SIM800 Modul antwortet */
int SIM800_WaitForReady()
{
  char response[32];
  char* p = response;
    
  serialSIM800.print(F("AT\r\n"));
  delay(200);
  
   while (serialSIM800.available() )
   {
    *p = serialSIM800.read();
    Serial.write(*(p++));
   }
   *p = '\0';
   
   p = response;    
   if (strcmp(p,"AT\r\r\nOK\r\n")!= 0)
    Serial.println("falsch!");
  else 
    Serial.println("richtig!");
  
}

[derjaeger (Gast)]

So könnte es auch gehen:

int SIM800_WaitForReady()
{
  char response[32];

  serialSIM800.setTimeout(50);

  serialSIM800.print(F("AT\r\n"));
  delay(200);
  serialSIM800.readBytes(response, 32);

  String response_comp = String(response);
  if(response_comp == "AT\r\r\nOK\r\n")  
    Serial.println("falsch!");
  else 
    Serial.println("richtig!");
  
}

Was ist F("AT\r\n") ? Warum nicht einfach println("AT") ?

[derjaeger (Gast)]

Natürlich ist das obige if-Konstrukt vertauscht ..

Richtiger Weise:

int SIM800_WaitForReady()
{
  char response[32];

  serialSIM800.setTimeout(50);

  serialSIM800.print(F("AT\r\n"));
  delay(200);
  serialSIM800.readBytes(response, 32);

  String response_comp = String(response);
  if(response_comp != "AT\r\r\nOK\r\n")  
    Serial.println("falsch!");
  else 
    Serial.println("richtig!");
  
}

[Stefan F. (Gast)]

Chris J. schrieb:
> Aber selbst hier scheitert es schon, weil ich nicht genau
> weiss, was da exakt rauskommt

Damit hatte ich auch beim ESP822 gekämpft, zudem sich die Details eine 
Zeitlang mit jedem Firmware Release änderten. Ich kenne die Problematik 
aber auch von älteren GSM Modems, weil ich vor einigen Jahen ein Linux 
Programm schrieb, dass mit so ziemlich allen GSM Modems funktionieren 
sollte.

Ich empfehle folgende Methode: Schreibe Dir eine Funktion, die ein 
Kommando sendet und dann bis zu n Millisekunden auf ein bestimmtes Wort 
in der Response wartet. Zum Beispiel:

char responseBuffer[100];
bool gotOk = send_command("ATZ\r\n", "Ok", 500, responseBuffer, 
sizeof(responseBuffer));

Die Funktion soll in diesem Fall "ATZ" senden, dann bis zu 500ms lang 
auf "Ok" warten. Wenn das soweit klappte, liefert sie ein true zurück, 
sonst false. Der responseBuffer ist optional und wird mit der kompletten 
Antwort befüllt, oder mit so vielen Zeichen wie hinein passen. Falls der 
Buffer zu klein ist, werden die überschüssigen empfangenen Zeichen 
einfach verworfen.

Und jetzt kommt der entscheidende Trick: Nachdem die Funktion das 
erwartete Stichwort empfangen hat, empfängt sie zusätzlich solange alle 
weiteren Zeichen, bis 100ms nicht mehr kommt. Diese 100ms kannst du 
ruhig hardcodieren, die wirst du kaum ändern wollen.

Wenn das Modem nicht mit dem erwarteten Stichwort (Ok) antwortet, wartet 
die Funktion bis zu 500ms und liefert dann die Fehlermeldung zurück. Die 
kann man dann z.B. auf einem Display anzeigen.

Auf diese Weise wartest du nach jedem erfolgreichen Kommando immer lange 
genug, bis das Modem seine komplette Antwort gegeben hat. Erst danach 
wird dein Programm das nächste Kommando senden. Und das ist wichtig, 
weil es sonst die Synchronisation zum Modem verlieren würde, so dass es 
irgendwann die Antworten nicht mehr zu den richtigen Kommando zuordnen 
würde.

Wie die Zeilenumbrüche in der Antwort des Modems aussehen, ist 
irrelevant. Ich gehe da sogar noch einen Schritt weiter und ersetze 
einfach alle \r durch \n und verwerfe wiederholt aufeinanderfolgende \n. 
So vereinheitliche ich das Format der Antwort.

[Chris J. (Gast)]

derjaeger schrieb:
> as ist F("AT\r\n") ? Warum nicht einfach println("AT") ?

Das F legt den String ins Flash, sonst liegt der dauernd im Ram. Kommt 
vor allen Strings bei mir, zumindest den größeren.

Ich probiere  deines mal aus morgen, jetzt Ende... Netflix gucken.... 
Sleepy Hollow :-)

[Chris J. (Gast)]

Stefanus F. schrieb:
> Damit hatte ich auch beim ESP822 gekämpft, zudem sich die Details eine
> Zeitlang mit jedem Firmware Release änderten. Ich kenne die Problematik
> aber auch von älteren GSM Modems, weil ich vor einigen Jahen ein Linux
> Programm schrieb, dass mit so ziemlich allen GSM Modems funktionieren
> sollte.

Stefanus, ich danke Dir ertsmal für deine Mühe und deine Hilfe.... echt 
top! Ich schaue es mir morgen mal genau an und werde dann so verfahren 
um die Routinen sicher zu machen, dass sich da nichts aufhängt. Das SIM 
lässt sich ja auch updaten was die Firmware angeht aber mich brauch eh 
nur sms und das langt. Wird ein überwachungsgerät mit Radar sensor, was 
ich per sms steuern will.

Nochmal danke! Hast was gut!

[Chris J. (Gast)]

Hier stehts mit dem "F"
https://learn.adafruit.com/memories-of-an-arduino/optimizing-sram

Auch wichtig.... serial Basics:
http://forum.arduino.cc/index.php?topic=396450.0

Leider quasselt das Ding beim Starten auch noch ohne gefragt worden zu 
sein, was echt nervt.

[Stefan F. (Gast)]

Chris J. schrieb:
> Leider quasselt das Ding beim Starten auch noch ohne gefragt worden zu
> sein, was echt nervt.

Da fällt mir ein, was ich vergessen habe:

Bevor du ein Kommando sendest, leere den Empfangspuffer der seriellen 
Schnittstelle. Damit du nicht irgendwelche vorherigen Zwischenrufe des 
Modems irrtümlicherweise als Antwort interpretierst.

[Chris J. (Gast)]

Na, wenn die mit jeder neuen Firmware irgendwelche /r mehr einbringen, 
dann werden sich ja die Hersteller der Librarys freuen.... dass sie die 
alle in die Tonne hauen können.

Bis ich mit ATE0 das Echo abschalte bleibt das auch so. Ausgaben wie
von CPOL? sind ohnehin kaum zu interpretieren, das fehlt dann doch etwas 
ein Linux mit seinem awk, sed und anderen Sachen.

Das kennst du aber auch, oder?
https://www.tutorialspoint.com/c_standard_library/c_function_strstr.htm

[Chris J. (Gast)]

Hallo Stefanus,

wenn man erstmal drin ist, dann fluppt es ganz fix! Das Zauberwort 
heisst
strstr! leider kommt man nicht umher den Puffer immer wieder zu prüfen, 
da das Teil auch ungefragt quasselt, vor allem wenn man die RTC gesetzt 
hat quatscht es immer wieder mal ungefragt.

int SIM800_IsAnswerOK(const char* atc, const char* token)
{
  char response[64];
  char* p = response;
  int cnt = 0;
  
  while(Serial.available())        /* Buffer leeren */
    Serial.read();
    
  serialSIM800.print(atc);
  delay(500);  
  while (serialSIM800.available() && (cnt < sizeof(response))) {
    *(p++) = serialSIM800.read();
    cnt++;
  }
  
  if (cnt >= sizeof(response)-1)    /*Buffer Überlauf? */
    return 0;

  *p = '\0';              /* String Null terminieren */
  
  p = response;            /* Pointer zurück auf String */
  if(strstr(p,token)) {        /* OK prüfen */
    debug(atc);
    debug("Token: ");
    debug(token);
    debugln(F(" -> Token erkannt!"));
    return 1;
  } else {
    debug(atc);
    debugln(F(" -> Token NICHT erkannt!"));
  }
    
  
  return 0;
}

[derjaeger (Gast)]

>>Leider quasselt das Ding beim Starten auch noch ohne gefragt worden zu
sein, was echt nervt.

Können Bootloader Nachrichten sein.
Der EPS8266 quasselt beim Starten (wenn RESET losgelassen wird) für mehr 
als 350 ms irgendwelche Bootnachrichten ... unglaublich

[Chris J. (Gast)]

derjaeger schrieb:
> Können Bootloader Nachrichten sein.
> Der EPS8266 quasselt beim Starten (wenn RESET losgelassen wird) für mehr
> als 350 ms irgendwelche Bootnachrichten ... unglaublich

Der SIm800 quakt aber deutlich mehr..... vor allem wenn man die Uhrzeiut 
gesetzt hat, das muss aber abgeschaltet werden, geht gar nicht!

[Rufus Τ. F. (rufus)]

Chris J. schrieb:
> vor allem wenn man die Uhrzeiut gesetzt hat, das muss aber abgeschaltet
> werden, geht gar nicht!

Oder man muss sich einen anständigen Parser für die Antworten von dem 
Ding schreiben, der auch unerwartete Ausgaben tolerieren und von 
relevanten Informationen trennen kann.

Der sollte natürlich auch mit jeder beliebigen Variante von 
Zeilentrennern zurechtkommen, und nicht sklavisch "\r\n" erwarten.

Dann stört auch ein Firmwareupdate nicht.

[Stefan F. (Gast)]

Ich finde sehr gut, dass du hier nicht die String Klasse verwendet hast, 
um die einzelnen Zeichen einzusammeln. Sie wäre deutlich ineffizienter 
und mit Strings kann man auch sehr schnell unerwartete 
Speicher-Fragmentierung erzeugen.

Der delay(500) gefällt mir aber nicht. Damit verlangsamst du die 
Kommunikation unnötig. Ich würde das eher so angehen:

char response[64];
uint8_t cnt = 0;
uint8_t success=0;

// Flush the serial buffer
while(Serial.available())
{
    Serial.read();
    yield();
}

// Send command
serialSIM800.print(atc);  

// Wait up to 500ms for the expected token
long start=millis();
while (millis()-start<500)
{
    if (serialSIM800.available())
    {
        // Always read out the serial buffer
        // even if the response buffer is full
        char c=serialSIM800.read();
        if (cnt < sizeof(response)-1)
        { 
            response[cnt++] = c;
            response[cnt] = '\0';
            if(strstr(response,token)) 
            { 
                success=1;
                break;
            }
        }
    }
    yield();
}

// Receive 100ms additional characters after the token
long start=millis();
while (millis()-start<100)
{
    if (serialSIM800.available())
    {
        // Always read out the serial buffer
        // even if the response buffer is full
        char c=serialSIM800.read();
        if (cnt < sizeof(response)-1)
        { 
            response[cnt++] = c;
            response[cnt] = '\0';
        }
    }
    yield();
}

if(success) 
{
    debugln(F(" -> Token erkannt!"));
} 
else 
{
    debugln(F(" -> Token NICHT erkannt!"));
}

return success;

(Ich habe den Code nicht getestet, das überlasse ich Dir)

[Chris J. (Gast)]

Ok, habe ich übernommen, muss man trotzdem warten, 9600 baud sind nicht 
das Schnellste, sonst saugt man den Puffer leer bevor das letzte Zeichen 
da ist.

/*   ---------------------------------------------------------------------
  Sendet einen AT Befehl und prüft, ob Token in der Antwort
  vorkommt, was eine erfolgreiche Ausführung anzeigt.
  1 = OK, 0 = nicht ok. 2 = Timeout 
  ---------------------------------------------------------------------
*/  

int SIM800_IsAnswerOK(const char* atc, const char* token)
{
  char response[64];
  char* p = response;
  int cnt = 0;
  unsigned long to;
  
  while(Serial.available())        /* Buffer leeren */
    Serial.read();
    
  serialSIM800.print(atc);
  
  /* Warte 500ms auf das erste Zeichen des GSM Modems */
  to = millis();
  while (1) {
    if (((millis()- to) > 500))
      return 0;
    if (serialSIM800.available())
      break;
    yield();
  }
  
  /* Hole die Zeichen langsam ab */
  delay(50);
  while (serialSIM800.available() && (cnt < sizeof(response))) {
    *(p++) = serialSIM800.read();
    cnt++;
    delay(5);
    yield();
  }
  
  if (cnt >= sizeof(response)-1)    /*Buffer Überlauf? */
    return 0;

  *p = '\0';              /* String Null terminieren */
  
  p = response;            /* Pointer zurück auf String */
  debug(atc);
  debug("Token: ");
  debug(token);
  if(strstr(p,token)) {        /* OK prüfen */
    debugln(F(" -> Token erkannt!"));
    return 1;
  } else {
    debugln(F(" -> Token NICHT erkannt!"));
    return 0;
  }
  
  return 0;
}

[Chris J. (Gast)]

Rufus Τ. F. schrieb:
> Oder man muss sich einen anständigen Parser für die Antworten von dem
> Ding schreiben, der auch unerwartete Ausgaben tolerieren und von
> relevanten Informationen trennen kann.

Ich denke in prof. Anwendungen wird solch ein parser eh alles Int 
gesteuert heraus holen und die Antworten dann fein säuberlich zerlegt in 
structs ablegen. Aber für den haus Gebrauch sollte es reichen sich nur 
das heraus zu picken was man braucht und alle andere ignorieren. Und 
dafür taugt die Funktion strstr(hay, needle) eben recht gut. Kommt das 
was man erwartet ist es ok, wenn nicht Pech, dann while (1) Rote Led 
blinken:

[Chris J. (Gast)]

Kann man eigentlich diese blinkende rote LED auf den Modulen abschalten? 
Bei einem überwachungsgerät zwar nützlich zur Disgnose aber weniger im 
Betrieb.

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

Nicht daß ich wüsste. Im Zweifel halt ablöten oder einen Klecks nicht 
leitende Farbe drauf.

[Stefan F. (Gast)]

Chris J. schrieb:
> Ok, habe ich übernommen, muss man trotzdem warten,
> 9600 baud sind nicht das Schnellste, sonst saugt man
> den Puffer leer bevor das letzte Zeichen da ist.

Das war schon so beabsichtigt. Deswegen ja die while Schleife.

[Chris J. (Gast)]

Hast du ne Ahnung wie man es hinkriegen kann, dass das Modul sich eine 
eingehende Telefonnummer merkt und die dann als Ziel verwendet für sms?
Ich möchte die Anlage anrufen vom Handy, je nachdem welche ich grad habe 
und dann soll er auch auf die Nummer jeweils antworten. Ich weiss noch 
nicht, wie man bei einem eingehenden Anruf die Nummer herausfinden kann, 
die angerufen hat.

Notfalls schicke ich auch ne sms, wie beim Tracker mit begin und diese 
enthält ja auch wohl die Info wer die geschickt hat. Anrufen wäre aber 
billiger, weil ich da nicht abnehmen muss.

[Stefan F. (Gast)]

Nee, weiß ich nicht. Smartphones zeigen ja die Rufnummer des Anrufers 
an. Ich nehme an, dass dieses GSM modem das auch irgendwie kann. Oder 
man kann vielleicht die Historie der letzten Anrufer abfragen.

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

Das kann das GSM-Modul nicht alleine.

Meine AlarmSau macht sowas ähnliches, sind aber mehrere Schritte.

1. das GSM-Modul meldet eine ankommende SMS an den Controller
2. der Controller holt sich eine Liste der gespeicherten SMS
   (braucht man für die Speicherplatz-Nummer
3. der Controller holt sich die SMS vom Speicherplatz
4. der Controller prüft, ob die Telefonnummer der SMS bekannt ist und
   wenn ja, ob der User die Berechtigung für die Status-SMS hat
5. falls ja wird die Status-SMS zurückgeschickt (enthält so Daten wie
   Schärfungszustand, Netz- und Akkukontrolle, Alarmschleifen-Status)
6. die SMS wird mit der Speicherplatznummer vom Modul gelöscht

[Chris J. (Gast)]

Ich möchte dich mit deiner "AlarmSau" nicht verstimmen aber das geht 
ganz einfach und nicht so, wie beschrieben.

INT auf RING Pin oder Polling.
AT-CLIP=1
aktiviert die URC Meldungen

Beim Klingeln (RING = LOW) wird der String
+CLIP: "Nummer", Zusatzinfos erzeugt, den man ausliest und zerteilt
Fertig.

Alternativ pollt man auf das Wort RING in der Ausgabe des Moduls.

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

Dann hab ich nicht verstanden, was er will.

[S. R. (svenska)]

Chris J. schrieb:
>> Oder man muss sich einen anständigen Parser für die Antworten von dem
>> Ding schreiben, der auch unerwartete Ausgaben tolerieren und von
>> relevanten Informationen trennen kann.
>
> Ich denke in prof. Anwendungen wird solch ein parser eh alles Int
> gesteuert heraus holen und die Antworten dann fein säuberlich zerlegt in
> structs ablegen. Aber für den haus Gebrauch sollte es reichen sich nur
> das heraus zu picken was man braucht und alle andere ignorieren.

Äh, nein. Ein professioneller Parser besteht nicht daraus, zu wissen, 
wieviele Bytes ankommen und nur so viele Bytes zu lesen und dann stur in 
eine Struct zu packen. Das gibt es allerdings auch.

Wenn man es richtig machen will, dann definiert man die zu parsende 
Grammatik und generiert einen Parser dafür.

[Stefan F. (Gast)]

Ben B. schrieb:
> Dann hab ich nicht verstanden, was er will.

Er will sein gerät aus der Ferne aktivieren. Da SMS für ihn Geld kosten, 
will er das Gerät durch einen Anruf aktivieren. Einmal klingeln lassen, 
dann macht es irgendwas und schickt eine Antwort per SMS an die 
Rufnummer, die es aktiviert hat.

[Chris J. (Gast)]

S. R. schrieb:
> Wenn man es richtig machen will, dann definiert man die zu parsende
> Grammatik und generiert einen Parser dafür.

Ich denke ein Blick in das Datenbuch reicht um um zu verstehen, dass Du 
damit eine längere Zeit deines Lebens verbringen wirst, die Dir niemand 
bezahlt.

[S. R. (svenska)]

Chris J. schrieb:
> Ich denke ein Blick in das Datenbuch reicht um um zu verstehen, dass Du
> damit eine längere Zeit deines Lebens verbringen wirst, die Dir niemand
> bezahlt.

Ich muss nicht den gesamten AT-Befehlssatz inklusive sämtlicher 
historischen und herstellerspezifischen Bestandteile parsen, sondern nur 
den Teil, der mich interessiert. Und den Rest ignorieren.

Besser als strstr() auf nur mäßig definierte Buffer loszulassen ist das 
allemale.

[Chris J. (Gast)]

Wer mal mit dem Typen zu tun hatte, also ganz direkt life merkt zwar 
schnell dass das ein Soziopath ist - aber programmieren kann er. 
Trotzdem wurde er als Externer aus dem Projekt entlassen, weil keiner 
mit ihm klar kam.

Gibt es alles schon für den ARM. Müsste nur portiert werden:

https://github.com/MaJerle/GSM_AT_commands_parser/tree/master/00-GSM_LIBRARY

[Stefan F. (Gast)]

Chris J. schrieb:
> Wer mal mit dem Typen zu tun hatte, also ganz direkt life merkt zwar
> schnell dass das ein Soziopath ist - aber programmieren kann er.
> Trotzdem wurde er als Externer aus dem Projekt entlassen, weil keiner
> mit ihm klar kam.

Wer ist "er"?

[Chris J. (Gast)]

Egal. Weisst Du wie man einen eingehenden Anruf, der nicht abgenommen 
wurden auf Besetzt kriegt?

ATH?
AT+CHUP?

Das Netz gibt dazu nicht viel her. Bin grad bei der Rufannahme und 
Unterscheidung ob Anruf oder sms. Sprenge schon die 10kb Grenze :-)

[Stefan F. (Gast)]

Chris J. schrieb:
>> Wer mal mit dem Typen zu tun hatte, also ganz direkt life merkt zwar
>> schnell dass das ein Soziopath ist - aber programmieren kann er.
>> Trotzdem wurde er als Externer aus dem Projekt entlassen, weil keiner
>> mit ihm klar kam.

Stefanus F. schrieb:
> Wer ist "er"?

Chris J. schrieb:
> Egal.

Das ist keine akzeptable Antwort für so eine heftige Aussage.

Egal wen du meinst, solltest du vor dem Lästern an folgendes denken: Die 
allermeisten Ü40 jährigen Computer Experten hatten in ihrer Jugend-Zeit 
keine Chance auf eine ordentliche Berufsausbildung, weil es diese 
schlicht nicht gab. Sie haben den Umgang mit dem Computer autodidaktisch 
gelernt, und zwar ohne Internet, ohne Youtube und ohne Aliexpress. 
Außerdem kostete ein anständiger Computer damals noch ein Monatsgehalt.

Was denkst du, was das für Menschen sind, die ihre gesamte Freizeit mit 
der Erforschung der Computertechnik verbracht haben? Ich würde sie als 
Kellerkinder bezeichnen, oder Männer mit wenig Freunden.

Die einen kommen gut mit Menschen klar, die andere eher mit Maschinen. 
Erst seit Einführung der vernetzten Kommunikation in all ihren 
Ausprägungen (Fido Netz, Usenet, Email, Whatsapp, Facebook, ...) 
verschwimmen die Grenzen. Heute kan mann den ganzen Tag vor dem Computer 
hocken um Menschen zu kontaktieren. Damals hockte man jedoch vor dem 
Computer, um Menschen aus dem Weg zu gehen oder weil man einfach keine 
Freunde hatte.

Das Wort "Soziopath" ist aber schon harter Tobak, das sollte man nicht 
ohne Nachdenken benutzen.

> Weisst Du wie man einen eingehenden Anruf, der nicht abgenommen
> wurden auf Besetzt kriegt?

Ich glaube, mit ATH. Aber solche Details können Gerätespezifisch 
unterschiedlich sein. Meine praktischen Erfahrungen mit GSM Modems 
endeten vor 10 Jahren mit Geräten, die man heute nicht mehr kaufen kann.

> Das Netz gibt dazu nicht viel her.

Hast du keine Bedienungsanleitung? Irgendwo muss der Hersteller doch 
seinen Befehlssatz dokumentiert haben.

[Stefan F. (Gast)]

https://www.elecrow.com/download/SIM800%20Series_AT%20Command%20Manual_V1.09.pdf

AT+GSMBUSY
Reject incoming call

Wie du siehst brauchte ich dafür 5 Minuten.

[Chris J. (Gast)]

Stefan, wir kommen etwas vom Thema ab. Ich habe eine Weile im Jahre 2000 
als Asic Entwickler (VHDL) bei einem japanischen Konzern gearbeitet und 
hatte noch in der Probezeit den Eindruck, dass um mich herum eine Reihe 
Voll-Fach-Idioten sitzt, die man besser nicht auf die Menschheit los 
lässt. Arroganz, Rivalität und masslose Selbstüberschätzung prägten den 
Arbeitstag. Das schlimmste Arbeitsklima was ich je erlebt habe, bevor 
ich von Automotive nach Automation wechselte. Nerds, die mit niemandem 
ein normales Wort reden konnten, weil sie aus ihren Welten gar nicht 
mehr auftauchten. Der Begriff "Nerd" trifft es besser, weil bei 
Soziolpath noch eine Empathielosigkeit und schizophrene Komponente zu 
hinzu kommt.

Ich habs schon, es geht mit ATH0.  Macht jedenfalls mehr Spass es selbst 
zu schreiben als Dinge zu benutzen, die man nicht versteht und die auch 
nicht unbedingt funktionieren.

AT+GSMBUSY
Reject incoming call

Wie du siehst brauchte ich dafür 5 Minuten.

Tja, und deswegen klappt das auch nicht damit den aktiven Ruf 
abzulehnen. Auf die Idee kam ich auch schon :-)

[S. R. (svenska)]

Stefanus F. schrieb:
> Wie du siehst brauchte ich dafür 5 Minuten.

Ich habe so das dunkle Gefühl, dass Chris hier schon unter anderem Namen 
angemeldet war. Sowohl das Verhalten, als auch ein paar Aussagen passen 
zu einer anderen Person mit ähnlichem Namen.

[Chris J. (Gast)]

S. R. schrieb:
> Ich habe so das dunkle Gefühl, dass Chris hier schon unter anderem Namen
> angemeldet war. Sowohl das Verhalten, als auch ein paar Aussagen passen
> zu einer anderen Person mit ähnlichem Namen.

Ich bin seit 2004 hier, habe den Thread "Zeigt her Eure Kunstwerke" 
damals ins Leben gerufen und ich heisse immer noch Christian. Und ja, 
wir kennen uns von früher, Z80 und so. Und manche hier können sich auch 
nicht benehmen, das ist richtig.

[Chris J. (Gast)]

Ben B. schrieb:
> Die Abfrage der Uhrzeit (das Modul bekommt die Uhrzeit nach der Einwahl
> aus dem Netz) und des Batteriestatus ist ein einfaches AT-Kommando
> (AT+CCLK und AT+CBC). Das braucht man nur senden und das Modul antwortet
> entsprechend.

Hallo Ben,
ich habe mir zwar etwas Forenabstinenz verordnet aber nach vielen 
Stunden Programmierarbeit funktioniert mein Wachhund theoretisch. 
Zumindest die Kommunikation mit dem Handy klappt in beide Richtungen. 
Ich kann die Kiste fernsteuern mit einfachen Kommandos. 16kb C-Code, ca 
2000 Zeilen.

Aber..... der Sensor produziert ständig Fehlarlarme, ist quasi nicht 
verwendbar. Nach vielen Tests steht soviel fest, dass dieser RCWL 0516 
und das GSM Modul sich nicht direkt nebeneinander vertragen. Selbst 4cm 
Abstand reichen nicht. Kaum steckt es in der Platine fängt der Sensor 
Ausgang an zu flackern, bis zum Dauer-EIN Im Sleep Mode und wenn das GSM 
abgezogen ist beruhigt er sich und funktioniert.

Damit nicht viele Stunden Arbeit umsonst waren frage ich mal wie Du das 
Problem gelöst hast?

Gruss,
Christian

[Ben B. (Firma: Funkenflug Industries) (stromkraft)]

Bitte entschuldige, aber ich bin nicht damit einverstanden, wie ihr bei 
dem "Projekt" eure Mitarbeiter behandelt - z.B. rausschmeißen und als 
Soziopathen abstempeln anstatt mal zu überlegen woher die Probleme 
vielleicht kommen könnten und evtl. zu helfen - und daher bleibt mir 
nur, Dir mit Deinen eigenen Problemen noch viel Spaß zu wünschen.