Uno sendet nicht alleine

Wim H. OP #4943681
Lesenswert?
• ▲
▼ 
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?
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Wim H. OP #4943711
Lesenswert?
• ▲
▼ 
Hier der Code:

1
    #include <SoftwareSerial.h>

2
    #include <OneWire.h>                               // DS1820 Bibliothek einbinden 

3
    const unsigned int BAUDRATE       =  9600;         // Serieller Monitor Baud Rate

4
    const byte TEMPSENSORPIN          =  10;            // DS1820 Datenpin mit DP7 verbinden

5
    OneWire oneWire(TEMPSENSORPIN);                    // Object oneWire an DP7 erzeugen

6
    byte noOfSensor = 0;                               // Zähler für Anzahl Sensoren

7
    /***  Im Sketch unterstützte 1-Wire Temperatursensoren Maxim DS18xx  ***/

8
    const byte DS18S20ID              =  0x10;         // Family code of DS1820/DS18S20

9
    const byte DS18B20ID              =  0x28;         // Family code of DS18B20

10
    const byte DS1822ID               =  0x22;         // Family code of DS1822

11
    String content = "";

12
    char incoming_char = 0;

13
    int Test=1;

14
    

15
    SoftwareSerial sim800(8, 9); // RX, TX

16


17
    unsigned long myChannelNumber = 239893;

18
    String APIKey = "4E505ZX9E48NO766";  //write to thingspeak data store

19


20
    void setup()

21
    {

22
        /*****************************************************************************/

23
 /* Der nachfolgende Teil der Setup Routine ist optional und dient nur dem Test

24
  * verschiedener Auflösungen des DS18B20 Sensors. DS1820 und DS18S20

25
  * unterstützen diese Funktion nicht! Dieser Teil kann daher ignoriert werden.

26
  * Bei Verwendung eines DS18B20 kann die standardmäßige Auflösung von 12 Bit

27
  * auch auf 11, 10, oder 9 Bit reduziert werden. Ein Vorteil dabei ist die

28
  * geringere Konversionszeit des Sensors.

29
  * In Byte 4 des Scratchpads stehen zur Einstellung der Auflösung des Sensors

30
  * die Bits 5 (R0) und 6 (R1) zur Verfügung. Da die Daten im Scratchpad des 

31
  * Sensors flüchtig sind und hier nicht explizit ins EEPROM gerettet werden,

32
  * kann hier relativ gefahrlos experimentiert werden. Weitere Details sind 

33
  * dazu auch im Datenblatt zu finden. Bei dem Kommando müssen immer

34
  * 3 Bytes geschrieben werden, die Alarmschwellen der Temperatur HIGH und 

35
  * LOW sowie das Konfigurationsbyte mit den beiden Bits zur Einstellung der

36
  * gewünschten Auflösung.

37
  * Zur Vereinfachung des Sketches muss die Adresse des gewünschten Sensors 

38
  * manuell in das nachfolgende Array DS18B20ADDRESS[8] eingetragen werden.

39
  * Die nachfolgenden 6 Zeilen Code müssen nun dazu aktiviert werden sowie 

40
  * eine der letzten 4 Zeilen dieses Blockes mit der gewünschte Auflösung. Es

41
  * darf nur eine Auflösung aktiviert werden, die anderen bleiben auskommentiert!

42
  */

43
//const byte DS18B20ADDRESS[8]    = {0x28, 0x61, 0x4F, 0x51, 0x04, 0x00, 0x00, 0xA5};

44
//oneWire.reset();

45
//oneWire.select(DS18B20ADDRESS);                  // Select your desired device

46
//oneWire.write(0x4E);                             // Command to write Scratchpad

47
//oneWire.write(0x4B);                             // Write Alarm HIGH

48
//oneWire.write(0x46);                             // Write Alarm LOW

49
//oneWire.write(0x7F);                             // Schreibe 12-bit Konfiguration

50
//oneWire.write(0x5F);                             // Schreibe 11-bit Konfiguration

51
//oneWire.write(0x3F);                             // Schreibe 10-bit Konfiguration

52
//oneWire.write(0x1F);                             // Schreibe 9-bit Konfiguration

53
 /*

54
  *                                    MSB                    LSB

55
  *                           Bit:      7  6   5   4  3  2  1  0

56
  * Konfigurationsregister Byte 4:      0  R1  R0  1  1  1  1  1

57
  * 

58
  * Sollte wider Erwarten an dieser Stelle etwas doch nicht ganz klappen, so muss

59
  * nur kurz die Stromversorgung getrennt werden, um den Sensor mit seinen 

60
  * Standard Konfigurationsdaten mit 12-bit Auflösung neu zu starten.

61
  */

62
  /*****************************************************************************/

63
      sim800.begin(9600);

64
      Serial.begin(9600);

65


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

67


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

69


70
      //do{

71
        sim800.println("ATZ");  //reset

72
        delay(500);

73
        show();

74


75
        sim800.println("AT");  //dummy zum aufwachen

76
        delay(500);

77
        show();

78


79
        sim800.println("AT+CSQ");  //dummy zum aufwachen

80
        delay(500);

81
        show();

82
        //sim800.println("AT+SLEDS=1,0,65535"); //LED AT+SLED=<mode>,<timer_on>,<timer_off> (ms)

83
        //sim800.println("AT+SLEDS=3,65535,0"); //LED AT+SLED=<mode>,<timer_on>,<timer_off> (ms)

84
        //sim800.println("AT+CNETLIGHT=0");  //oder LED ausschalten

85
        //delay(200);

86
        //show();

87


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

89
        delay(500);

90
        show();

91


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

93
        delay(500);

94
        show();

95


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

97
        delay(500);

98
        show();

99


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

101
        delay(500);

102
        show();

103


104
        sim800.println("AT+SAPBR=1,1");

105
        delay(30000);

106
        show();

107
      //}while (Test<1);

108
      

109
      sim800.println("AT+SAPBR=2,1");

110
      delay(500);

111
      show();

112


113
      sim800.println("AT+HTTPINIT");

114
      delay(500);

115
      show();

116
      

117
      Serial.println("ready...");

118
    }

119
     

120
    void loop()

121
    {

122


123
  byte i;                                          // Hilfsvariable für Schleife

124
  boolean present = false;                         // true wenn Sensor gefunden

125
  boolean typeOfSensor;                            // 1=DS1820/S20; 0=DS1822/B20

126
  byte data[9];                                    // Array für 9 Byte Scratchpad

127
  byte address[8];                                 // Array 8 Byte für ROM Adresse

128
  float celsius, fahrenheit;

129
  /***  Prüfe auf verfügbare Sensoren, schreibe Seriennummer in Adress Array  ***/

130
  if (!oneWire.search(address)) {                  // Suche nach allen DS18xx

131
    Serial.println();

132
    Serial.println("Keine weiteren Sensoren mit gueltiger Seriennummer gefunden!");

133
    Serial.println("------------------------------------------------------------");

134
    oneWire.reset_search();                        // Kein neuer Fund, Suche zurücksetzen

135
    delay(500);                                    // Verzögerung für bessere Lesbarkeit

136
    noOfSensor = 0;                                // Gerätezähler zurücksetzen

137
    return;

138
  }

139
  /***  Drucke alle ROM Codes und zeige Typ des Sensors, Addresse und CRC  ***/

140
  Serial.print(noOfSensor += 1);

141
  Serial.print(". ");

142
  Serial.print("ROM =");

143
  for (i = 0; i < 8; i++) {

144
    Serial.write(' ');                             // Leerzeichen

145
    /***  Zeige 0x für Hexwerte mit ggf. führender 0  ***/

146
    Serial.print("0x");

147
    if (address[i] <= 0xF)                         // Drucke führende 0

148
    {

149
      Serial.print("0");

150
    }

151
    Serial.print(address[i], HEX);                 // Drucke Hexwerte

152
  }

153
  /***  CRC von jedem Sensor auf Gültigkeit prüfen  ***/

154
  if (OneWire::crc8(address, 7) != address[7]) {

155
    Serial.println("CRC ungueltig!");

156
    return;

157
  }

158
  Serial.println();

159
  /***  Das erste ROM Byte enthält den Sensortyp und bestimmt damit  ***/

160
  /***  auch die Art und Weise der Temperaturauswertung  ***/

161
  switch (address[0]) {

162
    case DS18S20ID:

163
      Serial.println("  1-Wire Sensor ist DS1820/DS18S20");

164
      typeOfSensor = 1;                            // Typ 1 gemäß Byte 0

165
      break;

166
    case DS18B20ID:

167
      Serial.println("  1-Wire Sensor ist DS18B20");

168
      typeOfSensor = 0;                            // Typ 0 gemäß Byte 0

169
      break;

170
    case DS1822ID:

171
      Serial.println("  1-Wire Sensor ist DS1822");

172
      typeOfSensor = 0;                            // Typ 0 gemäß Byte 0

173
      break;

174
    default:

175
      Serial.println("Unbekannter Sensor!");

176
      return;

177
  }

178
  /*****************************************************************************/

179
  /***  Starte Konvertierung der Temperatur auch mit parasitärer Versorgung  ***/

180
  oneWire.reset();

181
  oneWire.select(address);

182
  oneWire.write(0x44, 1);                          // Temp.Konvertiertung, parasitär

183
  /***  Die Konvertierung der Temperatur im Sensor benötigt bis zu 750ms  ***/

184
  delay(1000);                                     // 750ms sollten auch reichen

185
  /***  Wähle Scratchpad anhand der ermittelten Adresse und lese Daten aus  ***/

186
  present = oneWire.reset();

187
  oneWire.select(address);

188
  oneWire.write(0xBE);                             // Kommando Lese Scratchpad

189
  /***  Zeige 9 Bytes des jeweiligen Scratchpads aller gefundenen Sensoren  ***/

190
  Serial.print("  Data = ");

191
  for ( i = 0; i < 9; i++) {                       // 9 Byte Array auslesen

192
    data[i] = oneWire.read();

193
    Serial.print(data[i], HEX);                    // Werte Hexadezimal anzeigen

194
    Serial.print(" ");                             // Leerstelle drucken

195
  }

196
  /***  Überprüfe CRC aller vom Scratchpad eingelesenen 9 Bytes  ***/

197
  Serial.print("  CRC = ");

198
  Serial.print(OneWire::crc8(data, 8), HEX);       // CRC Check (data, length) HEX

199
  Serial.println();

200
  /*****************************************************************************/

201
  /***  Berechnung der Temperatur aus HIGH-Byte 1 und LOW-Byte 0 (Temperatur)  ***/

202
  /***  Der Umrechnungsfaktor ist abhängig von Sensor und Auflösung  ***/

203
  float factor = 0.0;                              // Factor depends on device

204
  int16_t tmp;                                     // Store 16-bit raw temperature

205
  /***  Prüfe auf DS1820 oder DS18S20 und erzeuge eine 16-bit Int Variable  ***/

206
  if (typeOfSensor == 1) {                         // Nur bei DS1820 oder DS18S20

207
    tmp = ((data[1] << 8) + data[0]);              // Generiere ein 16-bit Int tmp

208
    factor = 0.5;                                  // 0.5°C / Bit bei 9 Bit Aufl.

209
    float temp = tmp * factor;                     // Berechne temp

210
  }

211
  /***  Wenn kein DS1820 / DS18S20, dann muss es ein DS1822 / DS18B20 sein  ***/

212
  else {                                           

213
    /***  Prüfe die beiden Flags Bit 5/6 mit der Auflösung im Byte 4  ***/

214
    byte resolutionBits = data[4] & B01100000;     // Maskiere Bit 5 und 6

215
    /***  Als Dezimalzahl 0, 32, 64 oder 96 sind folgende Maskierungen ***/

216
    /***  entsprechend einer 9-, 10-, 11- oder 12-bit Auflösung möglich  ***/

217
    /***  Unbenutzte Bits haben keinen definierten Status! Daher auf 0 setzen  ***/

218
    switch (resolutionBits) {

219
      case 0:

220
        Serial.println("  Auflösung ist 9 Bit!");

221
        data[0] = data[0] & B11111000;             // Maskiere Bits für 9 Bit Auflösung

222
        break;

223
      case 32:

224
        Serial.println("  Auflösung ist 10 Bit!");

225
        data[0] = data[0] & B11111100;             // Maskiere Bits für 10 Bit Auflösung

226
        break;

227
      case 64:

228
        Serial.println("  Auflösung ist 11 Bit!");

229
        data[0] = data[0] & B11111110;             // Maskiere Bits für 11 Bit Auflösung

230
        break;

231
      case 96:

232
        Serial.println("  Auflösung ist 12 Bit!"); // Volle 12-bit Auflösung

233
        break;

234
      default:

235
        Serial.println("  Unbekannte Auflösung!");

236
        break;

237
    }

238
    tmp = ((data[1] << 8) + data[0]);              // Generiere 16-bit Int tmp

239
    factor = 0.0625;                               // 12-bit = 0,0625°C / Bit

240
  }

241
  /***  Berechne die Temperatur basierend auf der festgestellten Auflösung  ***/

242
  float temp = tmp * factor;                       // Auflösung 9 bis 12 Bit 

243
  Serial.print("  Temperatur ist ");

244
  Serial.print(temp);

245
  Serial.print(" Celsius bzw. ");

246
  fahrenheit = temp * 1.8 + 32.0;

247
  Serial.print(fahrenheit);

248
  Serial.println(" Fahrenheit");

249


250
      

251
//      String daten="field1="+temp;

252
      Serial.println(temp);

253


254
     //sending data via cellur

255
     //test site has poor 2G signal, repeated tries to increase success rate

256
      Serial.println("Hier geht es los");

257
      sim800.println("AT");  //dummy zum aufwachen

258
      delay(500);

259
      show();

260


261
      /*sim800.println("AT+CSQ");  //dummy zum aufwachen

262
      delay(200);

263
      show();

264
              

265
      delay(200);

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

267
      show();

268
      

269
      delay(200);

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

271
      show();

272
      

273
      delay(200);

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

275
      show();

276


277


278
      delay(1000);

279
      sim800.println("AT+SAPBR=1,1");

280
      show();

281
      

282
      delay(200);

283
      sim800.println("AT+HTTPINIT");

284
      show();

285


286
      delay(200);

287
      sim800.println("AT+HTTPDATA=100,10000");

288
      show();*/

289
      

290
      sim800.println("AT+HTTPPARA=\"URL\",\"http://api.thingspeak.com/update?key=" +APIKey +"&field1="+temp+ "\"");

291
      delay(1000);

292
      show();

293
      Serial.println("");

294
      

295
      sim800.println("AT+HTTPACTION=0");

296
      delay(500);

297
      show();

298
      

299
      /*delay(200);

300
      sim800.println("AT+HTTPTERM");

301
      show();     */ 

302
      

303
      //delay(6000000); //10min warten

304
      delay(60000);

305
    }

306


307


308
    void show()  //anzeigen

309
{

310
  content = "";

311
  while(sim800.available()!=0)

312
  {

313
   if( sim800.available() > 0 )

314
   {

315
 //Get the character from the cellular serial port.

316
 incoming_char = sim800.read();

317
 content = content + String(incoming_char);

318
   }

319
  }

320
  Serial.print(content);

321
  if (content="ERROR"){

322
    Test=0;

323
  }  

324
  }


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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Wim H. OP #4943796
Lesenswert?
• ▲
▼ 
Hab ich schon, das selbe Spiel.
Dann alles neu und nur die nackte Einwahl bis
1
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Marc V. (Firma: Vescomp) #4943816
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Wim H. OP #4943837
Lesenswert?
• ▲
▼ 
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?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Wim H. OP #4943855
Lesenswert?
• ▲
▼ 
1
    #include <SoftwareSerial.h>

2
    

3
    SoftwareSerial sim800(8, 9); // RX, TX

4


5


6
    void setup()

7
    {

8


9
      sim800.begin(9600);

10
      delay(5000);  //warten auf Modem

11
        sim800.println("ATZ");  //reset

12
        delay(500);

13
        sim800.println("AT");  //dummy zum aufwachen

14
        delay(500);

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

16
        delay(500);

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

18
        delay(500);

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

20
        delay(500);

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

22
        delay(500);

23
        sim800.println("AT+SAPBR=1,1");

24
        delay(30000);

25
        sim800.println("AT+SAPBR=2,1");

26
        delay(500);

27
        sim800.println("AT+HTTPINIT");

28
        delay(500);

29


30
    }

31
     

32
    void loop()

33
    {

34
    }


gerade probiert, dasselbe
Ist doch eigentlich richtig?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Marc V. (Firma: Vescomp) #4944076
Lesenswert?
• ▲
▼ 
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...
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Einer K. Gast #4944087
Lesenswert?
• ▲
▼ 
> 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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Beitrag #4944092 wurde von einem Moderator gelöscht.
Beitrag #4944116 wurde von einem Moderator gelöscht.
Marc V. (Firma: Vescomp) #4944137
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Rudi Trieb Gast #5503613
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren