Uno sendet nicht alleine

[Wim H. (wim1)]

Hallo

ich habe mir mit einem Uno und SIM800l einen Temperaturlogger
zusammengebastelt. Hängt er über USB am Rechner zu Kontrollzwecken, 
sendet er auch munter die Daten ins Web. Soll er aber alleine arbeiten, 
hat er keine Lust mehr und baut erst gar keine Verbindung auf. 
Kontrollieren kann ich dann ja nicht, wenn er aber wieder Verbindung zum 
Rechner bekommt, verbindet er über SIM800.
Jemand eine Idee?

[Einer K. (Gast)]

Klar!
Überprüfe doch mal die Schaltung und den Code.
Irgendwas ist da falsch.

[Kaj (Gast)]

Zeile 42...

Wie sollen wir wissen was du da gebaut hast?
Zeig deinen Code, sonst wird das nichts...

[Wim H. (wim1)]

Hier der Code:

    #include <SoftwareSerial.h>
    #include <OneWire.h>                               // DS1820 Bibliothek einbinden 
    const unsigned int BAUDRATE       =  9600;         // Serieller Monitor Baud Rate
    const byte TEMPSENSORPIN          =  10;            // DS1820 Datenpin mit DP7 verbinden
    OneWire oneWire(TEMPSENSORPIN);                    // Object oneWire an DP7 erzeugen
    byte noOfSensor = 0;                               // Zähler für Anzahl Sensoren
    /***  Im Sketch unterstützte 1-Wire Temperatursensoren Maxim DS18xx  ***/
    const byte DS18S20ID              =  0x10;         // Family code of DS1820/DS18S20
    const byte DS18B20ID              =  0x28;         // Family code of DS18B20
    const byte DS1822ID               =  0x22;         // Family code of DS1822
    String content = "";
    char incoming_char = 0;
    int Test=1;
    
    SoftwareSerial sim800(8, 9); // RX, TX

    unsigned long myChannelNumber = 239893;
    String APIKey = "4E505ZX9E48NO766";  //write to thingspeak data store

    void setup()
    {
        /*****************************************************************************/
 /* Der nachfolgende Teil der Setup Routine ist optional und dient nur dem Test
  * verschiedener Auflösungen des DS18B20 Sensors. DS1820 und DS18S20
  * unterstützen diese Funktion nicht! Dieser Teil kann daher ignoriert werden.
  * Bei Verwendung eines DS18B20 kann die standardmäßige Auflösung von 12 Bit
  * auch auf 11, 10, oder 9 Bit reduziert werden. Ein Vorteil dabei ist die
  * geringere Konversionszeit des Sensors.
  * In Byte 4 des Scratchpads stehen zur Einstellung der Auflösung des Sensors
  * die Bits 5 (R0) und 6 (R1) zur Verfügung. Da die Daten im Scratchpad des 
  * Sensors flüchtig sind und hier nicht explizit ins EEPROM gerettet werden,
  * kann hier relativ gefahrlos experimentiert werden. Weitere Details sind 
  * dazu auch im Datenblatt zu finden. Bei dem Kommando müssen immer
  * 3 Bytes geschrieben werden, die Alarmschwellen der Temperatur HIGH und 
  * LOW sowie das Konfigurationsbyte mit den beiden Bits zur Einstellung der
  * gewünschten Auflösung.
  * Zur Vereinfachung des Sketches muss die Adresse des gewünschten Sensors 
  * manuell in das nachfolgende Array DS18B20ADDRESS[8] eingetragen werden.
  * Die nachfolgenden 6 Zeilen Code müssen nun dazu aktiviert werden sowie 
  * eine der letzten 4 Zeilen dieses Blockes mit der gewünschte Auflösung. Es
  * darf nur eine Auflösung aktiviert werden, die anderen bleiben auskommentiert!
  */
//const byte DS18B20ADDRESS[8]    = {0x28, 0x61, 0x4F, 0x51, 0x04, 0x00, 0x00, 0xA5};
//oneWire.reset();
//oneWire.select(DS18B20ADDRESS);                  // Select your desired device
//oneWire.write(0x4E);                             // Command to write Scratchpad
//oneWire.write(0x4B);                             // Write Alarm HIGH
//oneWire.write(0x46);                             // Write Alarm LOW
//oneWire.write(0x7F);                             // Schreibe 12-bit Konfiguration
//oneWire.write(0x5F);                             // Schreibe 11-bit Konfiguration
//oneWire.write(0x3F);                             // Schreibe 10-bit Konfiguration
//oneWire.write(0x1F);                             // Schreibe 9-bit Konfiguration
 /*
  *                                    MSB                    LSB
  *                           Bit:      7  6   5   4  3  2  1  0
  * Konfigurationsregister Byte 4:      0  R1  R0  1  1  1  1  1
  * 
  * Sollte wider Erwarten an dieser Stelle etwas doch nicht ganz klappen, so muss
  * nur kurz die Stromversorgung getrennt werden, um den Sensor mit seinen 
  * Standard Konfigurationsdaten mit 12-bit Auflösung neu zu starten.
  */
  /*****************************************************************************/
      sim800.begin(9600);
      Serial.begin(9600);

      //delay(5000);  //warten auf Modem

      //sim800.println("AT+IFC=0, 0");

      //do{
        sim800.println("ATZ");  //reset
        delay(500);
        show();

        sim800.println("AT");  //dummy zum aufwachen
        delay(500);
        show();

        sim800.println("AT+CSQ");  //dummy zum aufwachen
        delay(500);
        show();
        //sim800.println("AT+SLEDS=1,0,65535"); //LED AT+SLED=<mode>,<timer_on>,<timer_off> (ms)
        //sim800.println("AT+SLEDS=3,65535,0"); //LED AT+SLED=<mode>,<timer_on>,<timer_off> (ms)
        //sim800.println("AT+CNETLIGHT=0");  //oder LED ausschalten
        //delay(200);
        //show();

        sim800.println("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"");
        delay(500);
        show();

        sim800.println("AT+SAPBR=3,1,\"APN\",\"web.vodafone.de\"");
        delay(500);
        show();

        sim800.println("AT+SAPBR=3,1,\"USER\",\"www\"");
        delay(500);
        show();

        sim800.println("AT+SAPBR=3,1,\"PWD\",\"www\"");
        delay(500);
        show();

        sim800.println("AT+SAPBR=1,1");
        delay(30000);
        show();
      //}while (Test<1);
      
      sim800.println("AT+SAPBR=2,1");
      delay(500);
      show();

      sim800.println("AT+HTTPINIT");
      delay(500);
      show();
      
      Serial.println("ready...");
    }
     
    void loop()
    {

  byte i;                                          // Hilfsvariable für Schleife
  boolean present = false;                         // true wenn Sensor gefunden
  boolean typeOfSensor;                            // 1=DS1820/S20; 0=DS1822/B20
  byte data[9];                                    // Array für 9 Byte Scratchpad
  byte address[8];                                 // Array 8 Byte für ROM Adresse
  float celsius, fahrenheit;
  /***  Prüfe auf verfügbare Sensoren, schreibe Seriennummer in Adress Array  ***/
  if (!oneWire.search(address)) {                  // Suche nach allen DS18xx
    Serial.println();
    Serial.println("Keine weiteren Sensoren mit gueltiger Seriennummer gefunden!");
    Serial.println("------------------------------------------------------------");
    oneWire.reset_search();                        // Kein neuer Fund, Suche zurücksetzen
    delay(500);                                    // Verzögerung für bessere Lesbarkeit
    noOfSensor = 0;                                // Gerätezähler zurücksetzen
    return;
  }
  /***  Drucke alle ROM Codes und zeige Typ des Sensors, Addresse und CRC  ***/
  Serial.print(noOfSensor += 1);
  Serial.print(". ");
  Serial.print("ROM =");
  for (i = 0; i < 8; i++) {
    Serial.write(' ');                             // Leerzeichen
    /***  Zeige 0x für Hexwerte mit ggf. führender 0  ***/
    Serial.print("0x");
    if (address[i] <= 0xF)                         // Drucke führende 0
    {
      Serial.print("0");
    }
    Serial.print(address[i], HEX);                 // Drucke Hexwerte
  }
  /***  CRC von jedem Sensor auf Gültigkeit prüfen  ***/
  if (OneWire::crc8(address, 7) != address[7]) {
    Serial.println("CRC ungueltig!");
    return;
  }
  Serial.println();
  /***  Das erste ROM Byte enthält den Sensortyp und bestimmt damit  ***/
  /***  auch die Art und Weise der Temperaturauswertung  ***/
  switch (address[0]) {
    case DS18S20ID:
      Serial.println("  1-Wire Sensor ist DS1820/DS18S20");
      typeOfSensor = 1;                            // Typ 1 gemäß Byte 0
      break;
    case DS18B20ID:
      Serial.println("  1-Wire Sensor ist DS18B20");
      typeOfSensor = 0;                            // Typ 0 gemäß Byte 0
      break;
    case DS1822ID:
      Serial.println("  1-Wire Sensor ist DS1822");
      typeOfSensor = 0;                            // Typ 0 gemäß Byte 0
      break;
    default:
      Serial.println("Unbekannter Sensor!");
      return;
  }
  /*****************************************************************************/
  /***  Starte Konvertierung der Temperatur auch mit parasitärer Versorgung  ***/
  oneWire.reset();
  oneWire.select(address);
  oneWire.write(0x44, 1);                          // Temp.Konvertiertung, parasitär
  /***  Die Konvertierung der Temperatur im Sensor benötigt bis zu 750ms  ***/
  delay(1000);                                     // 750ms sollten auch reichen
  /***  Wähle Scratchpad anhand der ermittelten Adresse und lese Daten aus  ***/
  present = oneWire.reset();
  oneWire.select(address);
  oneWire.write(0xBE);                             // Kommando Lese Scratchpad
  /***  Zeige 9 Bytes des jeweiligen Scratchpads aller gefundenen Sensoren  ***/
  Serial.print("  Data = ");
  for ( i = 0; i < 9; i++) {                       // 9 Byte Array auslesen
    data[i] = oneWire.read();
    Serial.print(data[i], HEX);                    // Werte Hexadezimal anzeigen
    Serial.print(" ");                             // Leerstelle drucken
  }
  /***  Überprüfe CRC aller vom Scratchpad eingelesenen 9 Bytes  ***/
  Serial.print("  CRC = ");
  Serial.print(OneWire::crc8(data, 8), HEX);       // CRC Check (data, length) HEX
  Serial.println();
  /*****************************************************************************/
  /***  Berechnung der Temperatur aus HIGH-Byte 1 und LOW-Byte 0 (Temperatur)  ***/
  /***  Der Umrechnungsfaktor ist abhängig von Sensor und Auflösung  ***/
  float factor = 0.0;                              // Factor depends on device
  int16_t tmp;                                     // Store 16-bit raw temperature
  /***  Prüfe auf DS1820 oder DS18S20 und erzeuge eine 16-bit Int Variable  ***/
  if (typeOfSensor == 1) {                         // Nur bei DS1820 oder DS18S20
    tmp = ((data[1] << 8) + data[0]);              // Generiere ein 16-bit Int tmp
    factor = 0.5;                                  // 0.5°C / Bit bei 9 Bit Aufl.
    float temp = tmp * factor;                     // Berechne temp
  }
  /***  Wenn kein DS1820 / DS18S20, dann muss es ein DS1822 / DS18B20 sein  ***/
  else {                                           
    /***  Prüfe die beiden Flags Bit 5/6 mit der Auflösung im Byte 4  ***/
    byte resolutionBits = data[4] & B01100000;     // Maskiere Bit 5 und 6
    /***  Als Dezimalzahl 0, 32, 64 oder 96 sind folgende Maskierungen ***/
    /***  entsprechend einer 9-, 10-, 11- oder 12-bit Auflösung möglich  ***/
    /***  Unbenutzte Bits haben keinen definierten Status! Daher auf 0 setzen  ***/
    switch (resolutionBits) {
      case 0:
        Serial.println("  Auflösung ist 9 Bit!");
        data[0] = data[0] & B11111000;             // Maskiere Bits für 9 Bit Auflösung
        break;
      case 32:
        Serial.println("  Auflösung ist 10 Bit!");
        data[0] = data[0] & B11111100;             // Maskiere Bits für 10 Bit Auflösung
        break;
      case 64:
        Serial.println("  Auflösung ist 11 Bit!");
        data[0] = data[0] & B11111110;             // Maskiere Bits für 11 Bit Auflösung
        break;
      case 96:
        Serial.println("  Auflösung ist 12 Bit!"); // Volle 12-bit Auflösung
        break;
      default:
        Serial.println("  Unbekannte Auflösung!");
        break;
    }
    tmp = ((data[1] << 8) + data[0]);              // Generiere 16-bit Int tmp
    factor = 0.0625;                               // 12-bit = 0,0625°C / Bit
  }
  /***  Berechne die Temperatur basierend auf der festgestellten Auflösung  ***/
  float temp = tmp * factor;                       // Auflösung 9 bis 12 Bit 
  Serial.print("  Temperatur ist ");
  Serial.print(temp);
  Serial.print(" Celsius bzw. ");
  fahrenheit = temp * 1.8 + 32.0;
  Serial.print(fahrenheit);
  Serial.println(" Fahrenheit");

      
//      String daten="field1="+temp;
      Serial.println(temp);

     //sending data via cellur
     //test site has poor 2G signal, repeated tries to increase success rate
      Serial.println("Hier geht es los");
      sim800.println("AT");  //dummy zum aufwachen
      delay(500);
      show();

      /*sim800.println("AT+CSQ");  //dummy zum aufwachen
      delay(200);
      show();
              
      delay(200);
      sim800.println("AT+SAPBR=3,1,\"APN\",\"web.vodafone.de\"");
      show();
      
      delay(200);
      sim800.println("AT+SAPBR=3,1,\"USER\",\"www\"");
      show();
      
      delay(200);
      sim800.println("AT+SAPBR=3,1,\"PWD\",\"www\"");
      show();


      delay(1000);
      sim800.println("AT+SAPBR=1,1");
      show();
      
      delay(200);
      sim800.println("AT+HTTPINIT");
      show();

      delay(200);
      sim800.println("AT+HTTPDATA=100,10000");
      show();*/
      
      sim800.println("AT+HTTPPARA=\"URL\",\"http://api.thingspeak.com/update?key=" +APIKey +"&field1="+temp+ "\"");
      delay(1000);
      show();
      Serial.println("");
      
      sim800.println("AT+HTTPACTION=0");
      delay(500);
      show();
      
      /*delay(200);
      sim800.println("AT+HTTPTERM");
      show();     */ 
      
      //delay(6000000); //10min warten
      delay(60000);
    }


    void show()  //anzeigen
{
  content = "";
  while(sim800.available()!=0)
  {
   if( sim800.available() > 0 )
   {
 //Get the character from the cellular serial port.
 incoming_char = sim800.read();
 content = content + String(incoming_char);
   }
  }
  Serial.print(content);
  if (content="ERROR"){
    Test=0;
  }  
  }

und der SIM800 hängt an PIN 8 und 9. Nur ohne den großen Bruder(PC) will 
er nicht.
Bin in der Richtung aber auch Anfänger.

[Marc V. (Firma: Vescomp) (logarithmus)]

Wim H. schrieb:
> Jemand eine Idee?

 LOL.
 Spannungsversorgung über USB ?

[Wim H. (wim1)]

Nein Spannungsversorgung über ArduiBox  mit 12V Spannungsregler an VIN.

[Frank E. (Firma: Q3) (qualidat)]

Hmmm ... übersichtlicher Code geht aber anders ... das sieht eher nach 
zusammenkopiert aus. Dann wäre auch die Fehlersuche einfacher ...

Und die Riesen-Delays sind auch irgendwie doof ... das muss auch anders 
gehen.

[Wim H. (wim1)]

ja, ich weiß.
Und die delay's waren mein Versuch, falls er mehr Zeit braucht.
Ich komme aus der Basic Ecke.

[Marc V. (Firma: Vescomp) (logarithmus)]

Wim H. schrieb:
> Nein Spannungsversorgung über ArduiBox  mit 12V Spannungsregler an VIN.

 War nicht ernst gemeint.
 Ich kenne mich mit Arduino nicht aus, aber kommentiere mal alles
 was mit Serial zu tun hat, aus.

 Wetten, dass es dann geht ?

[npn (Gast)]

Marc V. schrieb:
> Ich kenne mich mit Arduino nicht aus, aber kommentiere mal alles
>  was mit Serial zu tun hat, aus.
>
>  Wetten, dass es dann geht ?

Wetten, dass dann gar nichts mehr geht?
Das GSM-Modul will auch über die serielle angesprochen werden...

[Marc V. (Firma: Vescomp) (logarithmus)]

npn schrieb:
> Das GSM-Modul will auch über die serielle angesprochen werden...

 Ja, aber über SoftwareSerial.

[Wim H. (wim1)]

Hab ich schon, das selbe Spiel.
Dann alles neu und nur die nackte Einwahl bis

sim800.println("AT+HTTPINIT");

dasselbe.
Bei Verbindung mit Rechner blinkt das SIM800 schnell,wen es Verbindung 
hat.
Starte ich es ohne Rechner blinkt es langsam -> keine Verbindung. 
Rechner ran und es blinkt schnell, also Verbindung.

[Frank L. (hermastersvoice)]

dann poste doch endlich mal dein Schaltbild und Fotos vom Aufbau. Sollen 
hier Alle nur raten was du gebastelt hast?

[Marc V. (Firma: Vescomp) (logarithmus)]

Frank L. schrieb:
> dann poste doch endlich mal dein Schaltbild und Fotos vom Aufbau. Sollen
> hier Alle nur raten was du gebastelt hast?

 Und das Programm ohne Serial.print wo es angeblich auch nicht geht.

 Zwei Möglichkeiten:
 A) Dein Programm bleibt hängen weil Serial nicht gestartet werden kann.
 B) SIM800 braucht mehr Strom als dein Uno liefern kann.
    Zusätzlichen Strom zieht er über USB.

 Etwas anderes kann es nicht sein.

[Wim H. (wim1)]

OK Schaldbild kann ich nicht posten, weil ich es freihändisch aufgebaut 
habe.

@Marc Vesely Sim800 ist an einen
Neuftech LM2596S DC-DC Heruntergehen Schaltreglermodul verstellbarer 
Abwärtswandler
angeschlossen. Der soll 3A bringen.Soll doch reichen?

Was meinst du mit 'Serial nicht gestartet werden kann'?
In diese Richtung gehe ich auch, finde den Fehler bloß nicht.
Wie kann ich die Serial nur zu PIN 8-9 starten, aber nicht zu USB?

[Marc V. (Firma: Vescomp) (logarithmus)]

Wim H. schrieb:
> Wie kann ich die Serial nur zu PIN 8-9 starten, aber nicht zu USB?

 Einfach Serial.Begin(9600) und alle Zeilen mit Serial.print oder
 Serial.println auskommentieren.

 SoftwareSerial ist als sim800 deklariert worden, braucht dich nicht
 weiter zu interessieren.

[Wim H. (wim1)]

    #include <SoftwareSerial.h>
    
    SoftwareSerial sim800(8, 9); // RX, TX


    void setup()
    {

      sim800.begin(9600);
      delay(5000);  //warten auf Modem
        sim800.println("ATZ");  //reset
        delay(500);
        sim800.println("AT");  //dummy zum aufwachen
        delay(500);
        sim800.println("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"");
        delay(500);
        sim800.println("AT+SAPBR=3,1,\"APN\",\"web.vodafone.de\"");
        delay(500);
        sim800.println("AT+SAPBR=3,1,\"USER\",\"www\"");
        delay(500);
        sim800.println("AT+SAPBR=3,1,\"PWD\",\"www\"");
        delay(500);
        sim800.println("AT+SAPBR=1,1");
        delay(30000);
        sim800.println("AT+SAPBR=2,1");
        delay(500);
        sim800.println("AT+HTTPINIT");
        delay(500);

    }
     
    void loop()
    {
    }

gerade probiert, dasselbe
Ist doch eigentlich richtig?

[Marc V. (Firma: Vescomp) (logarithmus)]

Wim H. schrieb:
> Ist doch eigentlich richtig?

 Sollte sein.
 Bleibt nur die Möglichkeit B)

 Probiere es mal so (ohne Serial) aber mit eingestecktem USB Kabel.

 Und sende irgendetwas was du empfangen und kontrollieren kannst.

[Einer K. (Gast)]

Marc V. schrieb:
> A) Dein Programm bleibt hängen weil Serial nicht gestartet werden kann.
HardwareSeriell macht auf dem UNO keine Sorgen.
Kann immer "gestartet" werden.
... ka was "gestartet" hier bedeuten soll ....

[Marc V. (Firma: Vescomp) (logarithmus)]

Arduino F. schrieb:
>> A) Dein Programm bleibt hängen weil Serial nicht gestartet werden kann.
> HardwareSeriell macht auf dem UNO keine Sorgen.
> Kann immer "gestartet" werden.
> ... ka was "gestartet" hier bedeuten soll ....

 Woher soll ich denn wissen was beim Uno mit Serial.begin(9600) und
 danach mit Serial.print() passiert ?

 Es gibt auch blockierende write Functions nach serial.
 Zwischen M328 und USB-Chip auf dem UNO-Board könnten auch RTS und CTS
 vorhanden sein.

 Und wenn es nicht die Möglichkeit A) ist, bleibt nur noch die
 Möglichkeit B)

 P.S.
 Die dritte Möglichkeit wäre, dass die beiden ein gemeinsames GND
 erst über USB kriegen, kann ich mir aber kaum vorstellen...

[Einer K. (Gast)]

> Es gibt auch blockierende write Functions nach serial.
Das ist wahr!
Wenn die SendeFiFo voll ist, fängt Serial.print() an zu blockieren, bis 
es seine Zeichen los geworden ist.

Marc V. schrieb:
> Zwischen M328 und USB-Chip auf dem UNO-Board könnten auch RTS und CTS
>  vorhanden sein.
Könnten...
Ist aber nicht.
DTR ist da, um einen Reset des ATMega328P auszulösen.


Ich finde viel lustiger, dass  Wim Högström keinerlei Versuch 
unternimmt, die Rückgabe des SIM Moduls zu überprüfen.
Somit wird er auch nie erfahren, was das Modul ihm sagen möchte.
Und er wird nie nicht auf die Ansagen des Moduls reagieren können.

z.B. könnte er bei seinem Modul die Versorgungsspannung erfragen.


Was auch immer gerne wieder genommen wird:
Man darf diese Module nicht sofort anbrüllen...
Die sind selber ein µC. Bzw. haben einen.
Die brauchen einen Augenblick, um "wach" zu werden.
Das erkennt man ganz klar daran, dass sie nicht antworten, wenn sie 
nicht fit sind.
Allerdings sollte das 5000er Delay hier ausreichen.

[Marc V. (Firma: Vescomp) (logarithmus)]

Arduino F. schrieb:
> Ich finde viel lustiger, dass  Wim Högström keinerlei Versuch
> unternimmt, die Rückgabe des SIM Moduls zu überprüfen.

 Ich finde das eher... - na ja, sagen wir mal traurig.

 Schnelles blinken bedeutet erst mal gar nichts - und selbst wenn, es
 werden weder die Antworten von sim800 überprüft, noch wird irgendwo
 gecheckt ob das, was gesendet wurde auch tatsächlich ausgeführt wird.

[Rudi Trieb (Gast)]

Es ist eigentlich ziemlich offensichtlich. Deine externe 
Spannungsversorgung liefert nicht genug Milliampere. Kurzzeitig braucht 
das Modul eine sehr hohe Milliampere Zahl. Dein USB-Anschluss scheint 
diese hohe Milliampere Zahl zu liefern, weshalb das Modul dann auch 
funktioniert. Dein externe Spannungsversorgung ist, was die gelieferte 
Ampere Zahl betrifft, zu schwach ausgelegt. Wie viel Ampere liefert 
deine externe Stromversorgung maximal?

Gruß

Dipl.- Ing. R. Trieb

[Stefan F. (Gast)]

> Deine externe Spannungsversorgung liefert nicht genug Milliampere.

Das war vor mehr als einem Jahr!

[Wim H. (wim1)]

Nachtrag
Inzwischen läuft der Kram.
Es lag wohl daran, das ich in meiner Bastelecke fast keinen
Mobilfunkempfang habe. Irgendwie hat das USB-Kabel darauf einen
Einfluss. In freier Wildbahn funktioniere es einwandfrei.

[Beat (Gast)]

Stefanus F. schrieb:
> Das war vor mehr als einem Jahr!

Bravo, vielen Dank für diesen tollen Beitrag!