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?
Klar! Überprüfe doch mal die Schaltung und den Code. Irgendwas ist da falsch.
Zeile 42... Wie sollen wir wissen was du da gebaut hast? Zeig deinen Code, sonst wird das nichts...
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.
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.
ja, ich weiß. Und die delay's waren mein Versuch, falls er mehr Zeit braucht. Ich komme aus der Basic Ecke.
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 ?
:
Bearbeitet durch User
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...
npn schrieb: > Das GSM-Modul will auch über die serielle angesprochen werden... Ja, aber über SoftwareSerial.
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.
dann poste doch endlich mal dein Schaltbild und Fotos vom Aufbau. Sollen hier Alle nur raten was du gebastelt hast?
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.
:
Bearbeitet durch User
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?
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.
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?
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.
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 ....
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...
> 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.
Beitrag #4944092 wurde von einem Moderator gelöscht.
Beitrag #4944116 wurde von einem Moderator gelöscht.
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.
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
> Deine externe Spannungsversorgung liefert nicht genug Milliampere.
Das war vor mehr als einem Jahr!
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.
Stefanus F. schrieb: > Das war vor mehr als einem Jahr! Bravo, vielen Dank für diesen tollen Beitrag!
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.