Fórum témák

» Több friss téma
Fórum » Arduino
A klónok CH340 Soros-USB illesztőjének drivere (Letöltés)
Lapozás: OK   824 / 824
(#) asch válasza Keresztes Vitéz hozzászólására (») Nov 21, 2023 /
 
Mekkora az UART baud rate, amit meg kell valósítani? Létezik egy AltSoftSerial lib is, ami működik Atmega328-cal, és a szoftveres UART-tal ellentétben nem blokkoló módban működik mind a TX, mind az RX: https://www.arduino.cc/reference/en/libraries/altsoftserial/ Viszont lefoglal egy timert, amit lehet, hogy használsz az impulzusok kiadásához... Szóval meg kell szakérteni.

Ja, és az egyetlen UART sem szabadon használható az Arduino UNO-n, mert erről megy a programozás és debuggolás! Ezért is ésszerű UART-os feladatot több UART-os csippel csinálni.

Én is azt javasolnám, hogy vegyél egy olyan csipet és boardot, amin eleve van több serial, minek szivassa magát az ember? Az STM32-őkhöz például vannak a Nucleo boardok (Hestore-on is kapható), ilyennel van tapasztalatom és csupa jó. Ez is programozható Arduinoként, kis szerencsével az eredeti program életre kelthető ezzel is.
Vagy ha 8 bites AVR-en akarsz maradni, akkor ott van az Arduino mega2560, ebben egy nagyobb ATMega van, amin már van több hardveres UART.
A hozzászólás módosítva: Nov 21, 2023
(#) hadhazik válasza hadhazik hozzászólására (») Nov 21, 2023 /
 
Alakul a kód, de így még nem azonos időnként írja a displayre az adatokat.
Hogyan kellene megváltoztatni az azonos kiíráshoz?

  1. // 5 "independant" timed events.
  2. const long eventTime_1 = 1000; //Soros portra kiírja az akku paramétereket.
  3. const long eventTime_2 = eventTime_1 +2000; //Soros portra LoRa packet és displayre.
  4. const long eventTime_3 = eventTime_2 +1000; //Soros portra displayinfo kiírása.
  5. const long eventTime_4 = eventTime_3 +2000; //Displayre kordináták kiírása.
  6. const long eventTime_5 = eventTime_4 +2000; //Displayre idő kiírása.
  7. //When did they start the race?.
  8. unsigned long previousTime_1 = 0;
  9. unsigned long previousTime_2 = 0;
  10. unsigned long previousTime_3 = 0;
  11. unsigned long previousTime_4 = 0;
  12. unsigned long previousTime_5 = 0;
(#) asch válasza hadhazik hozzászólására (») Nov 21, 2023 /
 
Van ez a sor a kódodban, ez nagyon nem jó, az aktuális idővel plusz 10 milliszekundummal növeled a startpontot (ismétlődő rossz minta a kódban, egyet másoltam ide):
  1. start1Millis += millis() + 10;

Helyette egy periódusidővel kell növelni a startpontot:
  1. const long periodMillis=4000;
  2. ...
  3. start1Millis += periodMillis;

Másik probléma, hogy a millis() átfordul néhány óránként, vagy naponként (nézz utána) a számábrázolás végessége miatt. Ezért a kisebb-nagyobb kérdést így kell eldönteni:
  1. if (millis() > start1Millis)

helyett:
  1. if (( (signed long)(millis()-start1Millis))>0)

Magyarázat: a különbségképzés akkor is jól működik, ha éppen átfordultunk a két érték között. (Ameddig a különbségek kisebbek mint az átfordulás periódusának a fele.) (Kukacoskodóknak megjegyzés: a C szabvány az előjeles átfordulás módját nem specifikálja, ha a szabvány szerint korrektek akarunk lenni, akkor csak unsigned esetben számolhatunk azzal, hogy az átfordulás így működik. De még nem láttam olyan platformot, ahol nem így működött volna.)
A hozzászólás módosítva: Nov 21, 2023
(#) hadhazik válasza asch hozzászólására (») Nov 21, 2023 /
 
Köszönöm hogy foglalkoztál a kérdéssel, a fenti megoldásomban valami hasonlót találtam ki.
Ha jól gondolom a különböző periódusidők alkalmazását.
Az adott időzítéssel lefutnak a kódrészek periódikusan, a gond a kijelzőn ábrázolással van, nem meghatározott időnként és sorrendben jelennek meg az egyes programrészek.
(#) asch válasza hadhazik hozzászólására (») Nov 22, 2023 /
 
A fentebbi hozzászólásodba tett kódodban találtam ezeket a hibákat, amik valósak és pont az általad leírt hibajelenséget okozzák, nevezetesen, hogy a loop ütemei össze-vissza történnek.
(#) hadhazik válasza asch hozzászólására (») Nov 22, 2023 /
 
  1. ```cpp
  2. #include <LoRa.h>
  3. #include <TinyGPS++.h>
  4. #include "boards.h"
  5. TinyGPSPlus gps;
  6. #if !defined(LILYGO_TBeamS3_SUPREME_V3_0) && !defined(LILYGO_TBeam_V1_X)
  7. #error "The sketch is only suitable for boards carrying AXP192 or AXP2101 chips!"
  8. #endif
  9. uint32_t start1Millis; //Soros portra kiírja az akku adatait.
  10. uint32_t start2Millis; //Soros portra és displayre kiírja LoRa packetet
  11. uint32_t start3Millis; //Soros portra kiírja displayinfot.
  12. uint32_t start4Millis; //Displayre kiírja GPS kordinátákat.
  13. uint32_t start5Millis; //Displayre kiírja GPS idő és magasság adatokat.
  14. void setup()
  15. {
  16.   initBoard();
  17.   delay(1500);
  18.    Serial.println("LoRa Receiver");
  19.  
  20.     LoRa.setPins(RADIO_CS_PIN, RADIO_RST_PIN, RADIO_DIO0_PIN);
  21.     if (!LoRa.begin(LoRa_frequency)) {
  22.         Serial.println("Starting LoRa failed!");
  23.         while (1);
  24.     }
  25.     Serial.println(F("DeviceExample.ino"));
  26.     Serial.println(F("A simple demonstration of TinyGPS++ with an attached GPS module"));
  27.     Serial.print(F("Testing TinyGPS++ library v. "));
  28.     Serial.println(TinyGPSPlus::libraryVersion());
  29.     Serial.println(F("by Mikal Hart"));
  30.     Serial.println();  
  31. }
  32. void loop()
  33. {
  34.  const long periodMillis=4000;
  35.  if (( (signed long)(millis()-start1Millis))>0)
  36.     {
  37.         Serial.print("isCharging:"); Serial.println(PMU->isCharging() ? "YES" : "NO");
  38.         Serial.print("isDischarge:"); Serial.println(PMU->isDischarge() ? "YES" : "NO");
  39.         Serial.print("isVbusIn:"); Serial.println(PMU->isVbusIn() ? "YES" : "NO");
  40.         Serial.print("getBattVoltage:"); Serial.print(PMU->getBattVoltage()); Serial.println("mV");
  41.         Serial.print("getVbusVoltage:"); Serial.print(PMU->getVbusVoltage()); Serial.println("mV");
  42.         Serial.print("getSystemVoltage:"); Serial.print(PMU->getSystemVoltage()); Serial.println("mV");
  43.         // The battery percentage may be inaccurate at first use, the PMU will automatically
  44.         // learn the battery curve and will automatically calibrate the battery percentage
  45.         // after a charge and discharge cycle
  46.         if (PMU->isBatteryConnect())
  47.         {
  48.             Serial.print("getBatteryPercent:"); Serial.print(PMU->getBatteryPercent()); Serial.println("%");
  49.         }
  50.         Serial.println();
  51.         start1Millis += periodMillis;
  52.     }
  53.     if (pmuInterrupt)
  54.     {
  55.         pmuInterrupt = false;
  56.         // Get PMU Interrupt Status Register
  57.         uint32_t status = PMU->getIrqStatus();
  58.         Serial.print("STATUS => HEX:");
  59.         Serial.print(status, HEX);
  60.         Serial.print(" BIN:");
  61.         Serial.println(status, BIN);
  62.         if (PMU->isVbusInsertIrq()) {
  63.             Serial.println("isVbusInsert");
  64.         }
  65.         if (PMU->isVbusRemoveIrq()) {
  66.             Serial.println("isVbusRemove");
  67.         }
  68.         if (PMU->isBatInsertIrq()) {
  69.             Serial.println("isBatInsert");
  70.         }
  71.         if (PMU->isBatRemoveIrq()) {
  72.             Serial.println("isBatRemove");
  73.         }
  74.         if (PMU->isPekeyShortPressIrq()) {
  75.             Serial.println("isPekeyShortPress");
  76.         }
  77.         if (PMU->isPekeyLongPressIrq()) {
  78.             Serial.println("isPekeyLongPress");
  79.         }
  80.         if (PMU->isBatChagerDoneIrq()) {
  81.             Serial.println("isBatChagerDone");
  82.         }
  83.         if (PMU->isBatChagerStartIrq()) {
  84.             Serial.println("isBatChagerStart");
  85.         }
  86.         // Clear PMU Interrupt Status Register
  87.         PMU->clearIrqStatus();
  88.     }
  89.   if (( (signed long)(millis()-start2Millis))>0)
  90.    {
  91.     // try to parse packet
  92.     int packetSize = LoRa.parsePacket();
  93.     if (packetSize)
  94.     {
  95.         // received a packet
  96.         Serial.print("Received packet ");
  97.         String recv = "";
  98.         // read packet
  99.         while (LoRa.available())
  100.         {
  101.             recv += (char)LoRa.read();
  102.         }
  103.         Serial.println(recv);
  104.         // print RSSI of packet
  105.         Serial.print("' with RSSI: ");
  106.         Serial.println(LoRa.packetRssi());      
  107.      #ifdef HAS_DISPLAY      
  108.         if (u8g2)
  109.         {      
  110.             u8g2->clearBuffer();
  111.             char buf[256];
  112.             u8g2->drawStr(0, 12, "Received OK!");
  113.             u8g2->setCursor(0, 25);
  114.             u8g2->print(PMU->getBattVoltage()); //u8g2->drawStr(0, 26, recv.c_str());
  115.             u8g2->println(" mV");
  116.             snprintf(buf, sizeof(buf), "RSSI:%i", LoRa.packetRssi());
  117.             u8g2->drawStr(0, 40, buf);
  118.             snprintf(buf, sizeof(buf), "SNR:%.1f", LoRa.packetSnr());
  119.             u8g2->drawStr(0, 56, buf);
  120.             while ( u8g2->nextPage() );
  121.             u8g2->sendBuffer();
  122.             u8g2->setFont(u8g2_font_fur11_tf);
  123.         start2Millis += periodMillis;
  124.         }
  125.     }
  126.     #endif
  127.    }
  128.      // This sketch displays information every time a new sentence is correctly encoded.
  129.     while (Serial1.available() > 0)
  130.         if (gps.encode(Serial1.read()))
  131.   if (( (signed long)(millis()-start3Millis))>0)      
  132.             {
  133.             displayInfo();
  134.         start3Millis += periodMillis;
  135.             }
  136.   if (( (signed long)(millis()-start4Millis))>0)
  137.    {
  138.     #ifdef HAS_DISPLAY
  139.     if (u8g2)
  140.     {
  141.         u8g2->clearBuffer();
  142.         do
  143.         {
  144.             u8g2->setCursor(0, 16);
  145.             u8g2->println( "Location.lat:");
  146.             u8g2->setCursor(0, 32);
  147.             u8g2->print(gps.location.lat(), 6);
  148.             u8g2->println(" deg");
  149.             u8g2->setCursor(0, 48);
  150.             u8g2->println( "Location.lng:");
  151.             u8g2->setCursor(0, 64);
  152.             u8g2->print(gps.location.lng(), 6);
  153.             u8g2->println(" deg");            
  154.         } while ( u8g2->nextPage() );
  155.         u8g2->sendBuffer();
  156.         u8g2->setFont(u8g2_font_fur11_tf);
  157.         start4Millis += periodMillis;
  158.     }
  159.          #endif
  160.    }
  161.   if (( (signed long)(millis()-start5Millis))>0)
  162.    {
  163.     #ifdef HAS_DISPLAY
  164.     if (u8g2)
  165.     {
  166.         u8g2->clearBuffer();
  167.         do
  168.         {
  169.             u8g2->setCursor(0, 16);
  170.             u8g2->print( "Hour:     ");
  171.             u8g2->println(gps.time.hour());
  172.             u8g2->setCursor(0, 32);
  173.             u8g2->print("minute:  ");
  174.             u8g2->println(gps.time.minute());
  175.             u8g2->setCursor(0, 48);
  176.             u8g2->print( "second:  ");
  177.             u8g2->println(gps.time.second());
  178.             u8g2->setCursor(0, 64);
  179.             u8g2->print("altitude: ");
  180.             u8g2->println(gps.altitude.meters());            
  181.         }
  182.         while ( u8g2->nextPage() );
  183.         u8g2->sendBuffer();
  184.         u8g2->setFont(u8g2_font_fur11_tf);
  185.         start5Millis += periodMillis;
  186.      }
  187.        #endif
  188.    }
  189.     if (millis() > 5000 && gps.charsProcessed() < 10)
  190.     {
  191.         Serial.println(F("No GPS detected: check wiring."));
  192.         while (true);
  193.     }
  194. }
  195. void displayInfo()
  196. {
  197.     Serial.print(F("Location: "));
  198.     if (gps.location.isValid())
  199.     {
  200.         Serial.print(gps.location.lat(), 6);
  201.         Serial.print(F(","));
  202.         Serial.print(gps.location.lng(), 6);
  203.     } else
  204.     {
  205.         Serial.print(F("INVALID"));
  206.     }
  207.  
  208.     Serial.print(F("  Date/Time: "));
  209.     if (gps.date.isValid())
  210.     {
  211.         Serial.print(gps.date.month());
  212.         Serial.print(F("/"));
  213.         Serial.print(gps.date.day());
  214.         Serial.print(F("/"));
  215.         Serial.print(gps.date.year());
  216.     } else
  217.     {
  218.         Serial.print(F("INVALID"));
  219.     }
  220.  
  221.     Serial.print(F(" "));
  222.     if (gps.time.isValid())
  223.     {
  224.         if (gps.time.hour() < 10) Serial.print(F("0"));
  225.         Serial.print(gps.time.hour());
  226.         Serial.print(F(":"));
  227.         if (gps.time.minute() < 10) Serial.print(F("0"));
  228.         Serial.print(gps.time.minute());
  229.         Serial.print(F(":"));
  230.         if (gps.time.second() < 10) Serial.print(F("0"));
  231.         Serial.print(gps.time.second());
  232.         Serial.print(F("."));
  233.         if (gps.time.centisecond() < 10) Serial.print(F("0"));
  234.         Serial.print(gps.time.centisecond());
  235.     } else
  236.     {
  237.         Serial.print(F("INVALID"));
  238.     }
  239.  
  240.     Serial.println();
  241. }
  242. ```


Displayen 2-es fut, 5-ös után 4-es bevillan, (5,4 3x), soros porton 1-es és 3-as fut, majd 2-es.
(#) Keresztes Vitéz válasza pipi hozzászólására (») Nov 22, 2023 /
 
Helló! Igazából semmi, de ha szoftveresen megoldható, az az igazi. Minél kevesebb alkatrész, annál jobb.
(#) Keresztes Vitéz válasza Pethical hozzászólására (») Nov 22, 2023 /
 
Úgy kell elképzelni, hogy mindkét tengelyen csak az egyik irány a "munkamenet", a másik irányban pedig minél gyorsabb visszaállítást kell megoldani.
(#) Keresztes Vitéz válasza asch hozzászólására (») Nov 22, 2023 /
 
Nincs megkötés a baud ratere. A chip nem Arduino boardon van, hanem direkt a feladatra tervezett pcb-n.
Valószínűleg tényleg egy másik chip lesz a végső megoldás.
(#) hadhazik válasza hadhazik hozzászólására (») Nov 22, 2023 /
 
  1. ```cpp
  2. #include <LoRa.h>
  3. #include <TinyGPS++.h>
  4. #include "boards.h"
  5. TinyGPSPlus gps;
  6. #if !defined(LILYGO_TBeamS3_SUPREME_V3_0) && !defined(LILYGO_TBeam_V1_X)
  7. #error "The sketch is only suitable for boards carrying AXP192 or AXP2101 chips!"
  8. #endif
  9. uint32_t start1Millis; //Soros portra kiírja az akku adatait.
  10. uint32_t start2Millis; //Soros portra és displayre kiírja LoRa packetet
  11. uint32_t start3Millis; //Soros portra kiírja displayinfot, displayre kiírja GPS kordinátákat.
  12. uint32_t start4Millis; //Displayre kiírja GPS idő és magasság adatokat.
  13. void setup()
  14. {
  15.   initBoard();
  16.   delay(1500);
  17.    Serial.println("LoRa Receiver");
  18.  
  19.     LoRa.setPins(RADIO_CS_PIN, RADIO_RST_PIN, RADIO_DIO0_PIN);
  20.     if (!LoRa.begin(LoRa_frequency)) {
  21.         Serial.println("Starting LoRa failed!");
  22.         while (1);
  23.     }
  24.     Serial.println(F("DeviceExample.ino"));
  25.     Serial.println(F("A simple demonstration of TinyGPS++ with an attached GPS module"));
  26.     Serial.print(F("Testing TinyGPS++ library v. "));
  27.     Serial.println(TinyGPSPlus::libraryVersion());
  28.     Serial.println(F("by Mikal Hart"));
  29.     Serial.println();  
  30. }
  31. void loop()
  32. {
  33.  const long periodMillis=4000;
  34.  if (( (signed long)(millis()-start1Millis))>0)
  35.     {
  36.         Serial.print("isCharging:"); Serial.println(PMU->isCharging() ? "YES" : "NO");
  37.         Serial.print("isDischarge:"); Serial.println(PMU->isDischarge() ? "YES" : "NO");
  38.         Serial.print("isVbusIn:"); Serial.println(PMU->isVbusIn() ? "YES" : "NO");
  39.         Serial.print("getBattVoltage:"); Serial.print(PMU->getBattVoltage()); Serial.println("mV");
  40.         Serial.print("getVbusVoltage:"); Serial.print(PMU->getVbusVoltage()); Serial.println("mV");
  41.         Serial.print("getSystemVoltage:"); Serial.print(PMU->getSystemVoltage()); Serial.println("mV");
  42.         // The battery percentage may be inaccurate at first use, the PMU will automatically
  43.         // learn the battery curve and will automatically calibrate the battery percentage
  44.         // after a charge and discharge cycle
  45.         if (PMU->isBatteryConnect())
  46.         {
  47.             Serial.print("getBatteryPercent:"); Serial.print(PMU->getBatteryPercent()); Serial.println("%");
  48.         }
  49.         Serial.println();
  50.         start1Millis += periodMillis;
  51.     }
  52.     if (pmuInterrupt)
  53.     {
  54.         pmuInterrupt = false;
  55.         // Get PMU Interrupt Status Register
  56.         uint32_t status = PMU->getIrqStatus();
  57.         Serial.print("STATUS => HEX:");
  58.         Serial.print(status, HEX);
  59.         Serial.print(" BIN:");
  60.         Serial.println(status, BIN);
  61.         if (PMU->isVbusInsertIrq()) {
  62.             Serial.println("isVbusInsert");
  63.         }
  64.         if (PMU->isVbusRemoveIrq()) {
  65.             Serial.println("isVbusRemove");
  66.         }
  67.         if (PMU->isBatInsertIrq()) {
  68.             Serial.println("isBatInsert");
  69.         }
  70.         if (PMU->isBatRemoveIrq()) {
  71.             Serial.println("isBatRemove");
  72.         }
  73.         if (PMU->isPekeyShortPressIrq()) {
  74.             Serial.println("isPekeyShortPress");
  75.         }
  76.         if (PMU->isPekeyLongPressIrq()) {
  77.             Serial.println("isPekeyLongPress");
  78.         }
  79.         if (PMU->isBatChagerDoneIrq()) {
  80.             Serial.println("isBatChagerDone");
  81.         }
  82.         if (PMU->isBatChagerStartIrq()) {
  83.             Serial.println("isBatChagerStart");
  84.         }
  85.         // Clear PMU Interrupt Status Register
  86.         PMU->clearIrqStatus();
  87.     }
  88.   if (( (signed long)(millis()-start2Millis))>0)
  89.    {
  90.     // try to parse packet
  91.     int packetSize = LoRa.parsePacket();
  92.     if (packetSize)
  93.     {
  94.         // received a packet
  95.         Serial.print("Received packet ");
  96.         String recv = "";
  97.         // read packet
  98.         while (LoRa.available())
  99.         {
  100.             recv += (char)LoRa.read();
  101.         }
  102.         Serial.println(recv);
  103.         // print RSSI of packet
  104.         Serial.print("' with RSSI: ");
  105.         Serial.println(LoRa.packetRssi());      
  106.      #ifdef HAS_DISPLAY      
  107.         if (u8g2)
  108.         {      
  109.             u8g2->clearBuffer();
  110.             char buf[256];
  111.             u8g2->drawStr(0, 12, "Received OK!");
  112.             u8g2->setCursor(0, 25);
  113.             u8g2->print(PMU->getBattVoltage()); //u8g2->drawStr(0, 26, recv.c_str());
  114.             u8g2->println(" mV");
  115.             snprintf(buf, sizeof(buf), "RSSI:%i", LoRa.packetRssi());
  116.             u8g2->drawStr(0, 40, buf);
  117.             snprintf(buf, sizeof(buf), "SNR:%.1f", LoRa.packetSnr());
  118.             u8g2->drawStr(0, 56, buf);
  119.             while ( u8g2->nextPage() );
  120.             u8g2->sendBuffer();
  121.             u8g2->setFont(u8g2_font_fur11_tf);
  122.         start2Millis += periodMillis;
  123.         }
  124.     }
  125.     #endif
  126.    }
  127.      // This sketch displays information every time a new sentence is correctly encoded.
  128.     while (Serial1.available() > 0)
  129.         if (gps.encode(Serial1.read()))
  130.   if (( (signed long)(millis()-start3Millis))>0)      
  131.             {
  132.             displayInfo();
  133.                 #ifdef HAS_DISPLAY
  134.     if (u8g2)
  135.     {
  136.         u8g2->clearBuffer();
  137.         do
  138.         {
  139.             u8g2->setCursor(0, 16);
  140.             u8g2->println( "Location.lat:");
  141.             u8g2->setCursor(0, 32);
  142.             u8g2->print(gps.location.lat(), 6);
  143.             u8g2->println(" deg");
  144.             u8g2->setCursor(0, 48);
  145.             u8g2->println( "Location.lng:");
  146.             u8g2->setCursor(0, 64);
  147.             u8g2->print(gps.location.lng(), 6);
  148.             u8g2->println(" deg");            
  149.         } while ( u8g2->nextPage() );
  150.         u8g2->sendBuffer();
  151.         u8g2->setFont(u8g2_font_fur11_tf);        
  152.     }
  153.          #endif
  154.         start3Millis += periodMillis +4000;        
  155.             }
  156.   if (( (signed long)(millis()-start4Millis))>0)
  157.    {
  158.     #ifdef HAS_DISPLAY
  159.     if (u8g2)
  160.     {
  161.         u8g2->clearBuffer();
  162.         do
  163.         {
  164.             u8g2->setCursor(0, 16);
  165.             u8g2->print( "Hour:     ");
  166.             u8g2->println(gps.time.hour());
  167.             u8g2->setCursor(0, 32);
  168.             u8g2->print("minute:  ");
  169.             u8g2->println(gps.time.minute());
  170.             u8g2->setCursor(0, 48);
  171.             u8g2->print( "second:  ");
  172.             u8g2->println(gps.time.second());
  173.             u8g2->setCursor(0, 64);
  174.             u8g2->print("altitude: ");
  175.             u8g2->println(gps.altitude.meters());            
  176.         }
  177.         while ( u8g2->nextPage() );
  178.         u8g2->sendBuffer();
  179.         u8g2->setFont(u8g2_font_fur11_tf);
  180.         start4Millis += periodMillis;
  181.      }
  182.        #endif
  183.    }
  184.     if (millis() > 5000 && gps.charsProcessed() < 10)
  185.     {
  186.         Serial.println(F("No GPS detected: check wiring."));
  187.         while (true);
  188.     }
  189. }
  190. void displayInfo()
  191. {
  192.     Serial.print(F("Location: "));
  193.     if (gps.location.isValid())
  194.     {
  195.         Serial.print(gps.location.lat(), 6);
  196.         Serial.print(F(","));
  197.         Serial.print(gps.location.lng(), 6);
  198.     } else
  199.     {
  200.         Serial.print(F("INVALID"));
  201.     }
  202.  
  203.     Serial.print(F("  Date/Time: "));
  204.     if (gps.date.isValid())
  205.     {
  206.         Serial.print(gps.date.month());
  207.         Serial.print(F("/"));
  208.         Serial.print(gps.date.day());
  209.         Serial.print(F("/"));
  210.         Serial.print(gps.date.year());
  211.     } else
  212.     {
  213.         Serial.print(F("INVALID"));
  214.     }
  215.  
  216.     Serial.print(F(" "));
  217.     if (gps.time.isValid())
  218.     {
  219.         if (gps.time.hour() < 10) Serial.print(F("0"));
  220.         Serial.print(gps.time.hour());
  221.         Serial.print(F(":"));
  222.         if (gps.time.minute() < 10) Serial.print(F("0"));
  223.         Serial.print(gps.time.minute());
  224.         Serial.print(F(":"));
  225.         if (gps.time.second() < 10) Serial.print(F("0"));
  226.         Serial.print(gps.time.second());
  227.         Serial.print(F("."));
  228.         if (gps.time.centisecond() < 10) Serial.print(F("0"));
  229.         Serial.print(gps.time.centisecond());
  230.     } else
  231.     {
  232.         Serial.print(F("INVALID"));
  233.     }
  234.  
  235.     Serial.println();
  236. }
  237. ```


A displayen 8 sec-ént kiírja a GPS időt, a GPS kordináták és a LoRa packet közben együtt, vagy egyedül.
(#) proba válasza hadhazik hozzászólására (») Nov 22, 2023 /
 
Ami eszembe jutott, ha már minden összevissza fut le, lehet a processzornak nincs ideje/nem kapja időben az adatokat. A másik, annyi serial.print utasítás van, de azt nem látom a baudrate mekkora. Lehet nincs is ideje mindent elrendezni.
(#) asch válasza hadhazik hozzászólására (») Nov 22, 2023 /
 
A startXMillis változók kezdeti értéke nincs beállítva, 0 vagy memóriaszemét lesz a kezdeti értékük. Ez zavarja össze. Ezekbe a perióduson belüli fázist kell beírni, például 1000, 2000, 3000, stb.
(#) hadhazik válasza asch hozzászólására (») Nov 22, 2023 /
 
  1. uint32_t start1Millis = 5000; //Soros portra kiírja az akku adatait.
  2. uint32_t start2Millis = 4000; //Soros portra és displayre kiírja LoRa packetet.
  3. uint32_t start3Millis = 3000; //Soros portra kiírja displayinfot.
  4. uint32_t start4Millis = 2000; //Displayre kiírja GPS kordinátákat.
  5. uint32_t start5Millis = 1000; //Displayre kiírja GPS idő és magasság adatokat.

Hogyan írjam 2>5>4>2 sorrendhez?
Displayen most 4 secenként változik, 2>5>4>5>4>5>4>2 sorrendben.

Baudrate: 115200

  1. ```cpp
  2. #include <LoRa.h>
  3. #include <TinyGPS++.h>
  4. #include "boards.h"
  5. TinyGPSPlus gps;
  6. #if !defined(LILYGO_TBeamS3_SUPREME_V3_0) && !defined(LILYGO_TBeam_V1_X)
  7. #error "The sketch is only suitable for boards carrying AXP192 or AXP2101 chips!"
  8. #endif
  9. uint32_t start1Millis = 5000; //Soros portra kiírja az akku adatait.
  10. uint32_t start2Millis = 4000; //Soros portra és displayre kiírja LoRa packetet.
  11. uint32_t start3Millis = 3000; //Soros portra kiírja displayinfot.
  12. uint32_t start4Millis = 2000; //Displayre kiírja GPS kordinátákat.
  13. uint32_t start5Millis = 1000; //Displayre kiírja GPS idő és magasság adatokat.
  14. void setup()
  15. {
  16.   initBoard();
  17.   delay(1500);
  18.    Serial.println("LoRa Receiver");
  19.  
  20.     LoRa.setPins(RADIO_CS_PIN, RADIO_RST_PIN, RADIO_DIO0_PIN);
  21.     if (!LoRa.begin(LoRa_frequency)) {
  22.         Serial.println("Starting LoRa failed!");
  23.         while (1);
  24.     }
  25.     Serial.println(F("DeviceExample.ino"));
  26.     Serial.println(F("A simple demonstration of TinyGPS++ with an attached GPS module"));
  27.     Serial.print(F("Testing TinyGPS++ library v. "));
  28.     Serial.println(TinyGPSPlus::libraryVersion());
  29.     Serial.println(F("by Mikal Hart"));
  30.     Serial.println();  
  31. }
  32. void loop()
  33. {
  34.  const long periodMillis=4000;
  35.  if (( (signed long)(millis()-start1Millis))>0)
  36.     {
  37.         Serial.print("isCharging:"); Serial.println(PMU->isCharging() ? "YES" : "NO");
  38.         Serial.print("isDischarge:"); Serial.println(PMU->isDischarge() ? "YES" : "NO");
  39.         Serial.print("isVbusIn:"); Serial.println(PMU->isVbusIn() ? "YES" : "NO");
  40.         Serial.print("getBattVoltage:"); Serial.print(PMU->getBattVoltage()); Serial.println("mV");
  41.         Serial.print("getVbusVoltage:"); Serial.print(PMU->getVbusVoltage()); Serial.println("mV");
  42.         Serial.print("getSystemVoltage:"); Serial.print(PMU->getSystemVoltage()); Serial.println("mV");
  43.         // The battery percentage may be inaccurate at first use, the PMU will automatically
  44.         // learn the battery curve and will automatically calibrate the battery percentage
  45.         // after a charge and discharge cycle
  46.         if (PMU->isBatteryConnect())
  47.         {
  48.             Serial.print("getBatteryPercent:"); Serial.print(PMU->getBatteryPercent()); Serial.println("%");
  49.         }
  50.         Serial.println();
  51.         start1Millis += periodMillis;
  52.     }
  53.     if (pmuInterrupt)
  54.     {
  55.         pmuInterrupt = false;
  56.         // Get PMU Interrupt Status Register
  57.         uint32_t status = PMU->getIrqStatus();
  58.         Serial.print("STATUS => HEX:");
  59.         Serial.print(status, HEX);
  60.         Serial.print(" BIN:");
  61.         Serial.println(status, BIN);
  62.         if (PMU->isVbusInsertIrq()) {
  63.             Serial.println("isVbusInsert");
  64.         }
  65.         if (PMU->isVbusRemoveIrq()) {
  66.             Serial.println("isVbusRemove");
  67.         }
  68.         if (PMU->isBatInsertIrq()) {
  69.             Serial.println("isBatInsert");
  70.         }
  71.         if (PMU->isBatRemoveIrq()) {
  72.             Serial.println("isBatRemove");
  73.         }
  74.         if (PMU->isPekeyShortPressIrq()) {
  75.             Serial.println("isPekeyShortPress");
  76.         }
  77.         if (PMU->isPekeyLongPressIrq()) {
  78.             Serial.println("isPekeyLongPress");
  79.         }
  80.         if (PMU->isBatChagerDoneIrq()) {
  81.             Serial.println("isBatChagerDone");
  82.         }
  83.         if (PMU->isBatChagerStartIrq()) {
  84.             Serial.println("isBatChagerStart");
  85.         }
  86.         // Clear PMU Interrupt Status Register
  87.         PMU->clearIrqStatus();
  88.     }
  89.   if (( (signed long)(millis()-start2Millis))>0)
  90.    {
  91.     // try to parse packet
  92.     int packetSize = LoRa.parsePacket();
  93.     if (packetSize)
  94.     {
  95.         // received a packet
  96.         Serial.print("Received packet ");
  97.         String recv = "";
  98.         // read packet
  99.         while (LoRa.available())
  100.         {
  101.             recv += (char)LoRa.read();
  102.         }
  103.         Serial.println(recv);
  104.         // print RSSI of packet
  105.         Serial.print("' with RSSI: ");
  106.         Serial.println(LoRa.packetRssi());      
  107.      #ifdef HAS_DISPLAY      
  108.         if (u8g2)
  109.         {      
  110.             u8g2->clearBuffer();
  111.             char buf[256];
  112.             u8g2->drawStr(0, 12, "Received OK!");
  113.             u8g2->setCursor(0, 25);
  114.             u8g2->print(PMU->getBattVoltage()); //u8g2->drawStr(0, 26, recv.c_str());
  115.             u8g2->println(" mV");
  116.             snprintf(buf, sizeof(buf), "RSSI:%i", LoRa.packetRssi());
  117.             u8g2->drawStr(0, 40, buf);
  118.             snprintf(buf, sizeof(buf), "SNR:%.1f", LoRa.packetSnr());
  119.             u8g2->drawStr(0, 56, buf);
  120.             while ( u8g2->nextPage() );
  121.             u8g2->sendBuffer();
  122.             u8g2->setFont(u8g2_font_fur11_tf);
  123.         start2Millis += periodMillis;
  124.         }
  125.     }
  126.     #endif
  127.    }
  128.      // This sketch displays information every time a new sentence is correctly encoded.
  129.     while (Serial1.available() > 0)
  130.         if (gps.encode(Serial1.read()))
  131.   if (( (signed long)(millis()-start3Millis))>0)      
  132.             {
  133.             displayInfo();
  134.          start3Millis += periodMillis;
  135.             }
  136.   if (( (signed long)(millis()-start4Millis))>0)
  137.   {                      
  138.     #ifdef HAS_DISPLAY
  139.     if (u8g2)
  140.     {
  141.         u8g2->clearBuffer();
  142.         do
  143.         {
  144.             u8g2->setCursor(0, 16);
  145.             u8g2->println( "Location.lat:");
  146.             u8g2->setCursor(0, 32);
  147.             u8g2->print(gps.location.lat(), 6);
  148.             u8g2->println(" deg");
  149.             u8g2->setCursor(0, 48);
  150.             u8g2->println( "Location.lng:");
  151.             u8g2->setCursor(0, 64);
  152.             u8g2->print(gps.location.lng(), 6);
  153.             u8g2->println(" deg");            
  154.         } while ( u8g2->nextPage() );
  155.         u8g2->sendBuffer();
  156.         u8g2->setFont(u8g2_font_fur11_tf);        
  157.     }
  158.          start4Millis += periodMillis;  
  159.          #endif      
  160.   }
  161.   if (( (signed long)(millis()-start5Millis))>0)
  162.    {
  163.     #ifdef HAS_DISPLAY
  164.     if (u8g2)
  165.     {
  166.         u8g2->clearBuffer();
  167.         do
  168.         {
  169.             u8g2->setCursor(0, 16);
  170.             u8g2->print( "Hour:     ");
  171.             u8g2->println(gps.time.hour());
  172.             u8g2->setCursor(0, 32);
  173.             u8g2->print("minute:  ");
  174.             u8g2->println(gps.time.minute());
  175.             u8g2->setCursor(0, 48);
  176.             u8g2->print( "second:  ");
  177.             u8g2->println(gps.time.second());
  178.             u8g2->setCursor(0, 64);
  179.             u8g2->print("altitude: ");
  180.             u8g2->println(gps.altitude.meters());            
  181.         }
  182.         while ( u8g2->nextPage() );
  183.         u8g2->sendBuffer();
  184.         u8g2->setFont(u8g2_font_fur11_tf);
  185.         start5Millis += periodMillis;
  186.      }
  187.        #endif
  188.    }
  189.     if (millis() > 5000 && gps.charsProcessed() < 10)
  190.     {
  191.         Serial.println(F("No GPS detected: check wiring."));
  192.         while (true);
  193.     }
  194. }
  195. void displayInfo()
  196. {
  197.     Serial.print(F("Location: "));
  198.     if (gps.location.isValid())
  199.     {
  200.         Serial.print(gps.location.lat(), 6);
  201.         Serial.print(F(","));
  202.         Serial.print(gps.location.lng(), 6);
  203.     } else
  204.     {
  205.         Serial.print(F("INVALID"));
  206.     }
  207.  
  208.     Serial.print(F("  Date/Time: "));
  209.     if (gps.date.isValid())
  210.     {
  211.         Serial.print(gps.date.month());
  212.         Serial.print(F("/"));
  213.         Serial.print(gps.date.day());
  214.         Serial.print(F("/"));
  215.         Serial.print(gps.date.year());
  216.     } else
  217.     {
  218.         Serial.print(F("INVALID"));
  219.     }
  220.  
  221.     Serial.print(F(" "));
  222.     if (gps.time.isValid())
  223.     {
  224.         if (gps.time.hour() < 10) Serial.print(F("0"));
  225.         Serial.print(gps.time.hour());
  226.         Serial.print(F(":"));
  227.         if (gps.time.minute() < 10) Serial.print(F("0"));
  228.         Serial.print(gps.time.minute());
  229.         Serial.print(F(":"));
  230.         if (gps.time.second() < 10) Serial.print(F("0"));
  231.         Serial.print(gps.time.second());
  232.         Serial.print(F("."));
  233.         if (gps.time.centisecond() < 10) Serial.print(F("0"));
  234.         Serial.print(gps.time.centisecond());
  235.     } else
  236.     {
  237.         Serial.print(F("INVALID"));
  238.     }
  239.  
  240.     Serial.println();
  241. }
  242. ```
A hozzászólás módosítva: Nov 22, 2023
(#) asch válasza hadhazik hozzászólására (») Nov 23, 2023 /
 
A periodMillis egy periódus hossza milliszekundumban. A startXMillis az, hogy a perióduson belül mikor indul el az adott feladat. Tehát a periodMillis-nek többnek kell lenni, mint a legnagyobb startXMillis ahhoz, hogy értelmes legyen. Ezen kívül a startXMillis-ek közötti különbségnek elégnek kell lenni arra, hogy az adott taszk lefusson, akkor fog tudni stabilan működni.
Én egyébként egy állapotgépes megoldást javasolnék arra, hogy sorban végigmenjen a program az összes állapoton, és ezt egészíteném ki azzal, hogy az állapotgépet például másodpercenként egyszer hívnám meg. Sokkal átláthatóbb lenne és nehezebb lenne elrontani. Általánosságban, ha a paramétereink között redundancia van, akkor azt el lehet rontani. A beállítási paramétereket úgy kell meghatározni, hogy azok között ne legyen redundancia, azaz egymástól függetlenül állíthatóak legyenek és minden ami az adott paramétertől függ, az automatikusan utánaálljon. A redundanciák nálad: a startXmillis értékek között valójában a különbség az ami számít, annak kellene a változónak lenni. A periodMillis pedig legnagyobb startXMillis érték plusz egy várakozás kell hogy legyen.
(#) hadhazik válasza asch hozzászólására (») Nov 23, 2023 /
 
  1. //Cikluson belül a futás indításának kezdete.
  2. uint32_t start1Millis =    0; //Soros portra kiírja az akku adatait.
  3. uint32_t start2Millis = 2000; //Soros portra és displayre kiírja LoRa packetet.
  4. uint32_t start3Millis = 4000; //Soros portra kiírja displayinfot.
  5. uint32_t start4Millis = 7000; //Displayre kiírja GPS kordinátákat.
  6. uint32_t start5Millis = 9000; //Displayre kiírja GPS idő és magasság adatokat.
  7. const long periodMillis=10000; // Egy ciklus teljes ideje.


Így viszonylag ciklikusan fut, néha ki-kimarad egy futás.
Minden LoRa packetet kiír, a GPS vétele is rendben.
Az még megfontolandó hogy szükséges-e a display mellett a soros portra írás is pl. terepen.
Az állapotgépes futtatást egy másik modulnál már néztem.
LoRaWan alkalmazásban hasonlóan érthető ismertetőt keresek, különös tekintettel a smart árammérők P1 portjának kiolvasására.
Lehet ezt is figyelembe kellene vennem adásnál:
"A harmonizált rendelet a végberendezésekben és az átjárókban alkalmazott rádiókra egyaránt 25 mW maximális adóteljesítményt enged meg. A sáv egyes részein az adási kitöltési tényező 0,1%, máshol 1% lehet. Ez a korlátozás azt jelenti, hogy egy adott frekvencián leadott 1 másodperces üzenet után 999, illetve 99 másodperc szünetet kell tartani. Az egytized másodperces üzenetcsomag esetén 99,9, illetve 9,9 másodperc adásszünet betartása kötelező! Ez a hatósági előírás fontos, mivel ez biztosítja, hogy az állandó helyre telepített berendezések egyike se uralhassa a sávot."
A hozzászólás módosítva: Nov 23, 2023
(#) MATA hozzászólása Hé, 18:49 /
 
Üdv mesterek!
A következő gondom lenne összeraktam egy kapcsolást ezt:
https://www.instructables.com/DIY-Multifunction-Energy-Meter-V20/
Feltöltöttem a Wemos D1 mini Pro-ra a kódot de csak azt írja ki hogy "Open Green Energy"
és mást semmit mi lehet itt a probléma?
Előre is köszönöm!
Itt a kód is:
  1. #define BLYNK_PRINT Serial
  2. #define BLYNK_MAX_READBYTES 512
  3.  
  4. #include <ESP8266WiFi.h>
  5. #include <BlynkSimpleEsp8266.h>
  6. #include <Wire.h>
  7. #include <Adafruit_INA219.h>
  8. #include <Adafruit_SSD1306.h>
  9. #include <OneWire.h>
  10. #include <DallasTemperature.h>
  11.  
  12. /****************************************************************************/
  13.  
  14. BlynkTimer timer;
  15. Adafruit_INA219 ina219;
  16. #define SCREEN_WIDTH 128 // OLED display width, in pixels
  17. #define SCREEN_HEIGHT 64 // OLED display height, in pixels
  18.  
  19. //   Virtual Pins - Base
  20.  
  21.  
  22. #define vPIN_VOLTAGE           V0
  23. #define vPIN_CURRENT           V1
  24. #define vPIN_POWER             V2
  25. #define vPIN_ENERGY            V3
  26. #define vPIN_CAPACITY          V4
  27. #define vPIN_TEMP              V5
  28. #define vPIN_CURRENT_GRAPH     V6
  29. #define vPIN_ENERGY_PRICE      V7
  30. #define vPIN_ENERGY_COST       V8
  31. #define vPIN_BUTTON_AUTORANGE  V9
  32.  
  33. // Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
  34.  
  35. Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
  36. // GPIO where the DS18B20 is connected to
  37. const int oneWireBus = 2;    
  38. // Setup a oneWire instance to communicate with any OneWire devices
  39. OneWire oneWire(oneWireBus);
  40. // Pass our oneWire reference to Dallas Temperature sensor
  41. DallasTemperature sensors(&oneWire);
  42.  
  43.  
  44. float shuntvoltage = 0.00;
  45. float busvoltage = 0.00;
  46. float current_mA = 0.00;
  47. float loadvoltage = 0.00;
  48. float energy = 0.00,  energyCost, energyPrevious, energyDifference;
  49. float energyPrice = 5.25 ;
  50. float power = 0.00;
  51. float tempC=0.00;
  52. float tempF=0.00;
  53. float capacity=0.00;
  54. int sendTimer, pollingTimer, priceTimer, graphTimer, autoRange, countdownResetCon, countdownResetClock, counter2, secret, stopwatchTimer;
  55. long stopwatch;
  56. int splitTimer1, splitTimer2, splitTimer3, splitTimer4, splitTimer5;
  57. int sendTimer1, sendTimer2, sendTimer3, sendTimer4, sendTimer5;
  58. unsigned long previousMillis = 0;
  59. unsigned long interval = 100;
  60.  
  61.  
  62.  
  63. char auth[] = "XXXX";   // Enter Blynk auth id
  64. char ssid[] = "XXXX";  //Enter your WIFI Name
  65. char pass[] = "XXXX";  //Enter your WIFI Password
  66.  
  67. /****************************************************************************/
  68.  
  69. void get_sensor_data() {
  70.  
  71.   // get the INA219 and DS18B20 Sensor values and throw some basic math at them  
  72.  
  73.   shuntvoltage = ina219.getShuntVoltage_mV();
  74.   busvoltage = ina219.getBusVoltage_V();
  75.   current_mA = ina219.getCurrent_mA();
  76.   loadvoltage = busvoltage + (shuntvoltage / 1000); // V
  77.   power = current_mA * loadvoltage ; // mW
  78.   energy = energy + (power / 1000 / 1000); //Wh
  79.   capacity = capacity + current_mA/1000;  
  80.  
  81.   // nothing connected? set all to 0, otherwise they float around 0.
  82.  
  83.   if (loadvoltage < 1.2 )loadvoltage = 0;
  84.   if(current_mA < 2 )
  85.   {    
  86.     current_mA = 0;
  87.     power = 0;
  88.     energy = 0;
  89.     capacity=0;
  90.     }    
  91.  
  92.   sensors.requestTemperatures(); // get temperatures
  93.   tempC = sensors.getTempCByIndex(0);
  94.   //tempF = sensors.getTempFByIndex(0);  
  95. }
  96.  
  97.  
  98. // this function is for updaing the REAL TIME values and is on a timer
  99.  
  100. void display_data() {
  101.  
  102.   // VOLTAGE
  103.  
  104.   Blynk.virtualWrite(vPIN_VOLTAGE, String(loadvoltage, 2) + String(" V") );
  105.   display.clearDisplay();
  106.   display.setCursor(0, 10);
  107.   display.print(loadvoltage);
  108.   display.print(" V");
  109.  
  110.   // CURRENT
  111.  
  112.   if (current_mA > 1000 && autoRange == 1) {
  113.     Blynk.virtualWrite(vPIN_CURRENT, String((current_mA / 1000), 3) + String(" A") );
  114.     display.setCursor(0, 30);
  115.     display.print((current_mA / 1000), 2);
  116.     display.print(" A");
  117.   } else {
  118.  
  119.     Blynk.virtualWrite(vPIN_CURRENT, String(current_mA, 2) + String(" mA"));
  120.     display.setCursor(0, 30);
  121.     display.print(current_mA,1);
  122.     display.print(" mA");
  123.   }  
  124.  
  125.   // POWER
  126.  
  127.   if (power > 1000 && autoRange == 1) {
  128.    Blynk.virtualWrite(vPIN_POWER, String((power / 1000), 3) + String(" W") );
  129.    display.setCursor(0, 50);
  130.    display.print(String((power / 1000),2));
  131.    display.print(" W");      
  132.  
  133.   } else {
  134.    Blynk.virtualWrite(vPIN_POWER, String(power, 0) + String(" mW") );
  135.    display.setCursor(0, 50);
  136.    display.print(power,0);
  137.    display.print(" mW");
  138.   }  
  139.  
  140.   energyDifference = energy - energyPrevious;
  141.   // ENERGY CONSUMPTION
  142.   if (energy > 1000 && autoRange == 1) {
  143.     Blynk.virtualWrite(vPIN_ENERGY, String((energy / 1000), 3) + String(" kWh"));
  144.     display.setCursor(70,10);
  145.     display.print((energy/1000),3);
  146.     display.println(" kWh");    
  147.   } else {
  148.  
  149.     Blynk.virtualWrite(vPIN_ENERGY, String(energy, 3) + String(" Wh"));
  150.     display.setCursor(70,10);
  151.     display.print(energy,3);
  152.     display.println(" Wh");  
  153.   }
  154.   energyPrevious = energy;  
  155.  
  156.   // ENERGY COST
  157.   energyCost = energyCost + ((energyPrice / 1000 / 100) * energyDifference);
  158.   if (energyCost > 9.999) {
  159.     Blynk.virtualWrite(vPIN_ENERGY_COST, String((energyCost),7));
  160.   } else {
  161.     Blynk.virtualWrite(vPIN_ENERGY_COST, String((energyCost), 7));
  162.   }
  163.  // CAPACITY
  164.  
  165.   if (capacity > 1000 && autoRange == 1){
  166.   Blynk.virtualWrite(vPIN_CAPACITY, String((capacity/ 1000), 2) + String(" Ah") );
  167.   display.setCursor(70,30);
  168.   display.print((capacity/1000),2);
  169.   display.println(" Ah");
  170.   }
  171.   else{
  172.   Blynk.virtualWrite(vPIN_CAPACITY, String((capacity), 2) + String(" mAh") );
  173.   display.setCursor(70,30);
  174.   display.print(capacity,1);
  175.   display.println(" mAh");
  176.   }
  177.   // TEMPERATURE
  178.  
  179.   display.setCursor(70,50);
  180.   display.print(tempC);  
  181.   display.println(" C");  
  182.  //display.println(" F");
  183.   Blynk.virtualWrite(vPIN_TEMP, String(tempC, 2) + String(" ºC") );
  184.   //Blynk.virtualWrite(vPIN_TEMP, String(tempF, 1) + String(" ºF") )
  185.   display.display();
  186.  
  187. }
  188.  
  189. // AUTO RANGE BUTTON
  190.  
  191. BLYNK_WRITE(vPIN_BUTTON_AUTORANGE) {
  192.   autoRange = param.asInt();
  193.   display_data();
  194. }
  195.  
  196.  
  197.  
  198. // the stopwatch counter which is run on a timer
  199.  
  200. void stopwatchCounter() {
  201.   stopwatch++;
  202.   long days = 0, hours = 0, mins = 0, secs = 0;
  203.   String secs_o = ":", mins_o = ":", hours_o = ":";
  204.   secs = stopwatch; //convect milliseconds to seconds
  205.   mins = secs / 60; //convert seconds to minutes
  206.   hours = mins / 60; //convert minutes to hours
  207.   days = hours / 24; //convert hours to days
  208.   secs = secs - (mins * 60); //subtract the coverted seconds to minutes in order to display 59 secs max
  209.   mins = mins - (hours * 60); //subtract the coverted minutes to hours in order to display 59 minutes max
  210.   hours = hours - (days * 24); //subtract the coverted hours to days in order to display 23 hours max
  211.   if (secs < 10) secs_o = ":0";
  212.   if (mins < 10) mins_o = ":0";
  213.   if (hours < 10) hours_o = ":0";
  214.  // Blynk.virtualWrite(vPIN_ENERGY_TIME, days + hours_o + hours + mins_o + mins + secs_o + secs);
  215.  
  216. }  
  217.  
  218.  
  219. /****************************************************************************/
  220.  
  221. void setup() {
  222.   Serial.begin(115200);
  223.     // initialize OLED display
  224.   display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  225.   display.clearDisplay();
  226.   display.setTextColor(WHITE);
  227.   display.setTextSize(1);
  228.   display.setCursor(12,25);
  229.   display.print("Open Green Energy");
  230.   display.display();
  231.   Serial.begin(115200);
  232.   Blynk.begin(auth, ssid, pass);
  233.  
  234.   // START INA219
  235.   ina219.begin();
  236.   sensors.begin();
  237.  
  238.   // TIMERS
  239.  
  240.   pollingTimer = timer.setInterval(1000, get_sensor_data);
  241.   graphTimer = timer.setInterval(4000, []() {
  242.   Blynk.virtualWrite(vPIN_CURRENT_GRAPH, current_mA);
  243.   });
  244.  
  245.   stopwatchTimer = timer.setInterval(1000, stopwatchCounter);
  246.  
  247.   // setup split-task timers so we dont overload ESP
  248.   // with too many virtualWrites per second
  249.   timer.setTimeout(200, []() {
  250.     sendTimer1 = timer.setInterval(2000, display_data);
  251.  
  252.   });    
  253.  
  254.  
  255.  
  256.   // start in auto-range mode & sync widget to hardware state
  257.   autoRange = 0;
  258.   Blynk.virtualWrite(vPIN_CURRENT_GRAPH, 1);
  259.   Blynk.virtualWrite(vPIN_ENERGY_PRICE, String(energyPrice, 4) );
  260. }
  261.  
  262. /****************************************************************************/
  263.  
  264. void loop() {
  265.   // the loop... dont touch or add to this!
  266.   Blynk.run();
  267.   timer.run();
  268. }
(#) pipi válasza MATA hozzászólására (») Hé, 23:16 /
 
Hali! 63-65 sorokat jól beállítottad?
A programodat rakosgasd tele Serial.print-el, akkor látod merre kóvályog a progi...
(#) MATA válasza pipi hozzászólására (») Kedd, 6:23 /
 
Hello!
Köszi a hozzászólást az igazából nem is kellene hogy én telefonon nézegessem a mért értékeket.
(#) Pethical válasza MATA hozzászólására (») Csü, 12:30 / 2
 
Ez a program arra való, hogy online nézegess dolgokat, direktbe becsattanan Blynkbe, ha ezek nincsenek beállítva, akkor a 232. sorban nem tud csatlakozni és megdöglik. Ha nem szeretnéd ezt, hanem elég a kijelző, akkor az összes blynk hívást írtsd ki belőle.
(#) MATA válasza Pethical hozzászólására (») Csü, 20:07 / 1
 
Hello!
Kiírtottam a Blynk hívásokat és láss csodát működik a dolog!
Köszönöm!
Következő: »»   824 / 824
Bejelentkezés

Belépés

Hirdetés
Lapoda.hu     XDT.hu     HEStore.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem