שְׁאֵלָה:
ESP8266 קריאה אנלוגית מפריעה ל- wifi?
JanG
2016-01-21 05:13:21 UTC
view on stackexchange narkive permalink

גרסה קצרה: יש לי תוכנית המחברת את ה- ESP8266 שלי ל- WIFI כדי שאוכל לשלוט בממסר המחובר אליו דרך האינטרנט או כפתור. יש לי גם חיישן לדלת. תוכנה זו עובדת בצורה מושלמת, אם אני מוסיף לה נגד תלוי אור (שמחובר נכון מכיוון שאני מקבל קריאות ממנה) ומתחיל לקרוא נתונים אני מאבד את חיבור ה- WIFI שלי. למישהו יש מושג מדוע זה קורה?

גרסה ארוכה:

אז יש לי את התוכנית הזו פועלת ב- Esp8266 שלי

  #include <ESP8266WiFi.h>IPAddress ip (192, 168, 0, 150); IPAddress gateway (192, 168, 0, 1); IPAddress רשת (255, 255, 255, 0); = "mySSID"; const char * password = "myPSW"; const char * host = "192.168.0.228"; const int buttonPin = 0; const int relayPin = 4; const int doorPin = 5; const int ldrPin = A0; / / int ldrState; // int serialCount = 0; // int ldrMin = 0; // int ldrMax = 1024; int buttonState = 0; int doorState = 0; byte Main_Light_State_Begin; bool Main_Light_State; bool door Notified = false; bool button_action_taken = false ; bool Main_Light_DBR = true; מחרוזת HTTP_Get_Response; שרת WiFiServer (80); // FuntionsString HTTP_Get (char * כתובת, URL מחרוזת, bool Last_Line_Bool) {לקוח WiFiClient; const int httpPort = 80; אם (! client.connect (כתובת, httpPort)) {Serial.println ("החיבור נכשל"); החזר "נכשל"; } Serial.print ("כתובת אתר מבקשת:"); Serial.println (URL); Serial.println ("בכתובת"); Serial.println (כתובת); client.print (String ("GET") + URL + "HTTP / 1.1 \ r \ n" + "מארח:" + כתובת + "\ r \ n" + "חיבור: סגור \ r \ n \ r \ n" ); עיכוב (10); תגובת מחרוזת; מחרוזת Last_Line; בעוד (client.available ()) {String line = client.readStringUntil ('\ r'); Serial.print (קו); תגובה = תגובה + קו; } השיב תגובה; Serial.println (); Serial.println ("סוגר חיבור");} הגדרת חלל () {Serial.begin (115200); עיכוב (1000); Serial.println (); Serial.println ();
Serial.print ("מתחבר אל"); Serial.println (ssid); WiFi.begin (ssid, סיסמה); WiFi.config (ip, gateway, subnet); בעוד (WiFi.status ()! = WL_CONNECTED) {עיכוב (500); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi מחובר"); server.begin (); - Serial.println ("השרת התחיל"); Serial.println (WiFi.localIP ()); pinMode (relayPin, OUTPUT); pinMode (buttonPin, INPUT); pinMode (doorPin, INPUT); // pinMode (ldrPin, INPUT);} loop loop () {if (WiFi.status ()! = WL_CONNECTED) {Serial.println ("Wifi NOT Connected"); } // חיישנים buttonState = digitalRead (buttonPin); doorState = digitalRead (doorPin); // ldrState = מפה (analogRead (ldrPin), ldrMin, ldrMax, 0, 100); //Serial.println(analogRead(ldrPin));;// if (serialCount == 1000) {// Serial.println (ldrState); // serialCount = 0; //} else {// serialCount ++; // } // Doorsensor if (doorState == HIGH) {if (doorNotified == false) {Serial.println ("DOOR"); HTTP_Get_Response = HTTP_Get ("192.168.0.228", "/index.php/?door_opened=true", שקר); doorNotified = נכון; }} אחר אם (doorState == LOW) {if (doorNotified == true) {doorNotified = false; עיכוב (500); } אחר {doorNotified = false; }} // כפתור if (buttonState == LOW) {if (button_action_taken == false) {if (Main_Light_State == true) {Serial.println ("SWITCH"); Main_Light_State = false; digitalWrite (relayPin, HIGH); עיכוב (500); Main_Light_DBR = false; } אחר אם (Main_Light_State == false) {Serial.println ("SWITCH"); Main_Light_State = true; digitalWrite (relayPin, LOW); עיכוב (500); Main_Light_DBR = false; } button_action_taken = נכון; }} אחרת אם (buttonState == HIGH) {if (button_action_taken == true) {button_action_taken = false; עיכוב (500); } אחר {button_action_taken = false; }} // Main_Light_State if (Main_Light_State == true) {
digitalWrite (relayPin, LOW); אם (Main_Light_DBR == false) {HTTP_Get_Response = HTTP_Get ("192.168.0.228", "/index.php/?main_light_on_dbr=true", false); Main_Light_DBR = נכון; }} אחרת אם (Main_Light_State == false) {digitalWrite (relayPin, HIGH); אם (Main_Light_DBR == false) {HTTP_Get_Response = HTTP_Get ("192.168.0.228", "/index.php/?main_light_off_dbr=true", false); Main_Light_DBR = נכון; }} לקוח WiFiClient = server.available (); אם (! לקוח) {להחזיר; } Serial.println ("לקוח חדש"); בעוד (! client.available ()) {עיכוב (1); } מחרוזת req = client.readStringUntil ('\ r'); Serial.println (req); client.flush (); אם (req.indexOf ("/ main_light / on")! = -1) {Main_Light_State = true; Main_Light_DBR = false; } אחר אם (req.indexOf ("/ main_light / off")! = -1) {Main_Light_State = false; Main_Light_DBR = false; } אחר אם (req.indexOf ("/ main_light / switch")! = -1) {Serial.println ("SWITCH"); אם (Main_Light_State == true) {Main_Light_State = false; } אחרת אם (Main_Light_State == false) {Main_Light_State = true; } Main_Light_DBR = false; } אחרת אם (req.indexOf ("/ main_light / state")! = -1) {} אחר {Serial.println ("בקשה לא חוקית"); client.stop (); לַחֲזוֹר; } client.flush (); מחרוזת s = "HTTP / 1.1 200 אישור \ r \ n תוכן-סוג: טקסט / html \ r \ n \ r \ n"; s + = (Main_Light_State)? "1": "0"; client.print (ים); עיכוב (1); Serial.println ("הלקוח נותק");}  

עם השורות שהגבתי כמו מעל הכל עובד בסדר. יש לי נגד תלוי אור מחובר (נכון, אני מקבל מדידות נכונות ממנו) ל- A0. מרגע ואילך אני מבטל את ההערה על הקווים הכוללים LDR זה ובכך מתחיל לקרוא נתונים ממנו אני מאבד את חיבור ה- wifi שלי. למישהו יש מושג מדוע זה? תודה לך!

* איזה * ESP8266? ישנן גרסאות רבות שלכל אחת יכולות ומתקנים שונים.
@Majenko זה עם שבב טורי וווסת ​​כוח. (Diymall NodeMCU Devkit 1.0 CP2102 IIC SPI עבור מערכת ההפעלה MAC של אפל https://www.amazon.co.uk/dp/B00XJG7GEK/ref=cm_sw_r_other_awd_UnhOwbBSFS1GS)
נתקלתי בזה כשחיפשתי מידע על בעיות AnalogRead. אני חושב של"פתרון האלגנטי יותר "עשויות להיות כמה בעיות. בעיה 1. אם הקריאה והעיבוד של החיישן נמשכים פחות מ -1 אלפיות השנייה, הלולאה עשויה לחזור ותקבלו מספר ביצועים של אנלוגי קריאה באותה אלפית השנייה - לא התוצאה הרצויה. בהתחשב בכך ש- AnalogRead (A0) עצמו לוקח רק כ- 70 מיקרו שניות, אם העיבוד הוא מהיר, תוכל בקלות לבצע 10 ביצועים של AnalogRead (A0) באותה אלפית השנייה. בעיה 2. אם יש דברים אחרים שעוברים עליהם מספר רב של מיליוני מילים להשלים (למשל
שְׁלוֹשָׁה תשובות:
JanG
2016-01-21 22:18:55 UTC
view on stackexchange narkive permalink

מצאתי שזה נגרם על ידי קריאת הסיכה האנלוגית פעמים רבות בפרק זמן קצר. החלפתי

  ldrState = map (analogRead (ldrPin), ldrMin, ldrMax, 0, 100); Serial.println (analogRead (ldrPin)); אם (serialCount == 1000) {Serial.println (ldrState); serialCount = 0; } אחר {serialCount ++; }  

עם זה:

  if (serialCount == 10000) {ldrState = map (analogRead (ldrPin), ldrMin, ldrMax, 0, 100) ; Serial.println (ldrState); serialCount = 0;} אחר {serialCount ++;}  

למרות שחשבתי על גישה זו בעבר, הטעות שלי הייתה שאני עדיין קורא את החיישן בכל פעם שהקוד לולאה, פשוט לא הייתי לא מדפיס אותו לצג הסדרתי עד לכל לולאה 100.

זה עדיין נותן לי קריאה מספר פעמים בשנייה, וזה הרבה יותר ממה שאני צריך. בכל מקרה, עכשיו אני יודע שאני לא יכול לקרוא את הסיכה האנלוגית ESP8266 שלי פעמים רבות בשנייה או שה- wifi יתנתק (לפחות כאשר משתמשים בו עם ה- Arduino IDE)

זה עובד מצוין, בדיוק הייתה הבעיה המדויקת הזו 4 שנים. מישהו יודע אם זה באג מדווח? זה כנראה צריך להיות.
Phil
2017-05-30 19:35:56 UTC
view on stackexchange narkive permalink

זו שאלה ישנה שנענתה עליה, אך ברצוני להציע פיתרון מעט אלגנטי יותר (IMO!):

בשיטה שלי שקוראת את הנתונים האנלוגיים, אני בודק וקורא רק כל 50 אלפיות השנייה:

  void readAnalogSensor () {if (millis ()% 50! = 0) return; . . // האם החיישן שלך קורא ועובד כאן.}  

זה מונע צורך לשמור על ספירת לולאות ונראה יותר דטרמיניסטי - ערך ספירת הלולאות לא בהכרח יגדל באופן עקבי בהתאם למה אחר קורה בלולאה. השימוש בערכי המיליס זמין שימושי גם אם אתה צריך ליישם קוד ביטול כפתור כלשהו.

וואו זה אכן עבר זמן מה, בנאדם אני צריך לבחור את הפרויקט הזה בחזרה! זה אכן פיתרון אלגנטי יותר, תודה!
farmerkeith
2017-10-16 14:27:11 UTC
view on stackexchange narkive permalink

הנה מה שאני עושה בדרך כלל בכדי לתת חזרה במרווחי זמן קבועים:

  void readAnalogSensor () {if (millis () <taskTime) return; // הזמן עדיין לא פג taskTime + = 50; // הגדר זמן לביצוע הבא // .... קוד נוסף למשימה שמתבצע כל 50 שניות}  

זה דורש taskTime משתנה ארוך ולא חתום . אתה יכול גם להשתמש בקבוע במקום 50.
יש להגדיר את taskTime לערך כלשהו קרוב ל millis () בסוף הגדרת () , אחרת יהיה רצף מהיר של הוצאות להורג בזמן ש taskTime תופס את millis () .

כמעט נכון. שכחת את העברת התזמון (https://playground.arduino.cc/Code/TimingRollover). כל 49 יום, המיליס () מתגלגל לאפס והרצון שלך משווה ערך נמוך מאוד (מיליס) לעומת ערך גדול מאוד (taskTime). הדרכים הנכונות הן תמיד להשוות את ההפרש בין `מילי ()` לעומת משך המרווח באלפיות השנייה.
תודה. רציתי להימנע מביצוע חשבון בכל מעבר של הלולאה, אך נראה כי הדבר אינו אפשרי מבלי לגרום לשגיאת ההתהפכות.
יש לך הרבה זמן לבזבז. אל תשכח כי התוכנית היחידה שלך פועלת. אין סיבה לשמור מחזורים אם אתה כבר מחכה.


שאלה ותשובה זו תורגמה אוטומטית מהשפה האנגלית.התוכן המקורי זמין ב- stackexchange, ואנו מודים לו על רישיון cc by-sa 3.0 עליו הוא מופץ.
Loading...