OK Mégsem
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   823 / 850
(#) scooby_ válasza Pethical hozzászólására (») Nov 18, 2023 /
 
Szia!
A cél az lenne, hogy a weben idönként frissüljön az érték.
Sajnos sehová nem jutottam vele, mert nem találtam róla infót. Próbáltam AI segítséget hívni, írt egy scriptet, de az sem működött egyáltalán.
(#) pipi válasza scooby_ hozzászólására (») Nov 18, 2023 /
 
Keresőszó: ajax microajax vagy xml...
(#) icserny válasza scooby_ hozzászólására (») Nov 18, 2023 / 3
 
Nézz szét az ESP8266 előadásaim között (főleg a 2020/2021. évad 16. és 17. előadása kellhet neked).
A rákövetkező évnél nagyjából ugyanezt ESP32-re is megtalálod.
(#) sargarigo válasza scooby_ hozzászólására (») Nov 18, 2023 /
 
De ha a head-be beleírod az alábbit, akkor a böngésző frissíti az oldalt 10s-enként.
  1. <meta http-equiv="refresh" content="10">
(#) Skori válasza sargarigo hozzászólására (») Nov 18, 2023 /
 
Azért az ajax sokkal jobb megoldás, mint az egész oldalt frissítgetni, és nem is bonyolult.
A websocket még jobb, de sokkal bonyolultabb megvalósítani...
(#) antikzsolt hozzászólása Nov 18, 2023 /
 
A kittben volt egy keyboard nevezetű eszköz. Hol tudnék rá venni számokat?
A hozzászólás módosítva: Nov 18, 2023

111111111111...png		    
(#) kaqkk válasza antikzsolt hozzászólására (») Nov 18, 2023 1 /
 
Hová szeretnél számot rakni ezekre a gombokra ?Bővebben: Link
A hozzászólás módosítva: Nov 18, 2023
(#) Pethical válasza scooby_ hozzászólására (») Nov 18, 2023 / 1
 
Kiindulásnak ez hátha segítség. Nem próbáltam ki

HTML + Javascript kód:
  1. <!DOCTYPE html>
  2. <html lang="hu">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <title>ESP8866 hőmérés</title>
  7. </head>
  8. <body>
  9.  
  10. <h1>Hőmérséklet: <span id="temperature">N/A °C</span></h1>
  11.  
  12. <script>
  13.     function fetchTemperature() {
  14.         fetch('/temperature')
  15.             .then(response => {
  16.                 if (!response.ok) {
  17.                     throw new Error('Hiba történt');
  18.                 }
  19.                 return response.text();
  20.             })
  21.             .then(data => {
  22.                 document.getElementById('temperature').innerText = data;
  23.             })
  24.             .catch(error => {
  25.                 console.error('Hiba történt: ', error);
  26.             });
  27.     }
  28.     setInterval(fetchTemperature, 10000); // 10 másodpercenként fog frissülni
  29.     fetchTemperature(); // Hogy azonnal jelenjen meg adat
  30. </script>
  31.  
  32. </body>
  33. </html>


ESP kódrészlet:
  1. //...
  2.  
  3. // Html fájl kiszolgálása
  4. server.on("/", HTTP_GET, []() {
  5.   server.send(200, "text/plain", A_MERT_HOMERSEKLET);
  6. });
  7.  
  8. // A hőmérsékletadat kiszolgálása
  9. server.on("/temperature", HTTP_GET, []() {
  10.   server.send(200, "text/html", A_FENTI_HTML);
  11. });
(#) antikzsolt válasza kaqkk hozzászólására (») Nov 18, 2023 /
 
Valami gombsort vagy bármit mert elég rossz nyomkodni a fekete kis gombokat.
Valami ilyesmire gondolok de magyarból.
Bővebben: Link
(#) Pethical válasza antikzsolt hozzászólására (») Nov 18, 2023 /
 
Ez így egyben árulják a NYÁK lappal, külön még nem láttam sehol sem.
Esetleg 3d nyomtatni tudsz rá, ha van 3d nyomtatód.
Vagy régi nyomógombos telefonból/billentyűzetből/számológépből lehet ki lehet szedni és ráragasztani, csak az nem lesz túl szép.
(#) antikzsolt válasza Pethical hozzászólására (») Nov 18, 2023 /
 
Ez nagyon kár olvasni. Marad a nyomtatás.
(#) Pethical válasza antikzsolt hozzászólására (») Nov 18, 2023 /
 
Azért hátha valaki tud olyat mondani, amit én nem vettem eddig észre és rávaló.
(#) scooby_ válasza Pethical hozzászólására (») Nov 20, 2023 /
 
Nagyon szépen köszönöm! Működik!

Talán csak egy pici gond volt vele:
  1. <h1>Hőmérséklet: <span id="temperature">N/A</span> °C</h1>


A fenti sor helyes. Ha a °C jelet a Span-hez rakod közvetlen a kijelzett vagy kijelzendő érték mögé, akkor a kijelzett érték miatt a jelzés törlődik. Így viszont egy szóközzel mindig ott lesz a kijelzett érték végén.
A hozzászólás módosítva: Nov 20, 2023
(#) scooby_ válasza icserny hozzászólására (») Nov 20, 2023 /
 
Köszönöm szépen!
Nagyon jók az előadásaid! Sokat tanultam most belőle!
(#) benjami válasza antikzsolt hozzászólására (») Nov 20, 2023 /
 
Thingiverse-n van hozzá burkolat terv. A keresőszó hozzá: "4x4 matrix 16 keys". Számok sajnos nincsenek rajta, ahhoz kicsit módosítani kell a terven, vagy matricát ráragasztani.
(#) hadhazik válasza hadhazik hozzászólására (») Nov 20, 2023 /
 
Lilygo
Megérkezett és megfelelő kódok is elérhetők hozzá.
Külön-külön a Lora, és GPS, akkumulátor kód működik, együtt nem, kezdődhet az összefésülés.
Először egyedi delay(); időzítésekkel néztem, a GPS folyamatosan működik, ha displayre kiíratom a LoRa csomagot nem írja ki, esetleg minimális időzítéssel néha. Gondolom a csomagok elkapásával van gond, hogyan is tároljam őket a folyamatos vétel fenntartásához?
A kód helyfoglalása bámulatosan kevés területet emészt fel, ez talán betudható a külön tárolt boards és utilities fájloknak.
A cél a displayre kiírás GPS és LoRa adatokkal + telep feszültség:

  1. #include <LoRa.h>
  2. #include <TinyGPS++.h>
  3. #include "boards.h"
  4. TinyGPSPlus gps;
  5. #if !defined(LILYGO_TBeamS3_SUPREME_V3_0) && !defined(LILYGO_TBeam_V1_X)
  6. #error "The sketch is only suitable for boards carrying AXP192 or AXP2101 chips!"
  7. #endif
  8. uint32_t startMillis;
  9. void setup()
  10. {
  11.   initBoard();
  12.   delay(1500);
  13.    Serial.println("LoRa Receiver");
  14.  
  15.     LoRa.setPins(RADIO_CS_PIN, RADIO_RST_PIN, RADIO_DIO0_PIN);
  16.     if (!LoRa.begin(LoRa_frequency)) {
  17.         Serial.println("Starting LoRa failed!");
  18.         while (1);
  19.     }
  20.     Serial.println(F("DeviceExample.ino"));
  21.     Serial.println(F("A simple demonstration of TinyGPS++ with an attached GPS module"));
  22.     Serial.print(F("Testing TinyGPS++ library v. "));
  23.     Serial.println(TinyGPSPlus::libraryVersion());
  24.     Serial.println(F("by Mikal Hart"));
  25.     Serial.println();  
  26. }
  27. void loop()
  28. {
  29.     if (millis() > startMillis)
  30.     {
  31.         Serial.print("isCharging:"); Serial.println(PMU->isCharging() ? "YES" : "NO");
  32.         Serial.print("isDischarge:"); Serial.println(PMU->isDischarge() ? "YES" : "NO");
  33.         Serial.print("isVbusIn:"); Serial.println(PMU->isVbusIn() ? "YES" : "NO");
  34.         Serial.print("getBattVoltage:"); Serial.print(PMU->getBattVoltage()); Serial.println("mV");
  35.         Serial.print("getVbusVoltage:"); Serial.print(PMU->getVbusVoltage()); Serial.println("mV");
  36.         Serial.print("getSystemVoltage:"); Serial.print(PMU->getSystemVoltage()); Serial.println("mV");
  37.         // The battery percentage may be inaccurate at first use, the PMU will automatically
  38.         // learn the battery curve and will automatically calibrate the battery percentage
  39.         // after a charge and discharge cycle
  40.         if (PMU->isBatteryConnect())
  41.         {
  42.             Serial.print("getBatteryPercent:"); Serial.print(PMU->getBatteryPercent()); Serial.println("%");
  43.         }
  44.         Serial.println();
  45.         startMillis += millis() + 1000;
  46.     }
  47.     if (pmuInterrupt)
  48.     {
  49.         pmuInterrupt = false;
  50.         // Get PMU Interrupt Status Register
  51.         uint32_t status = PMU->getIrqStatus();
  52.         Serial.print("STATUS => HEX:");
  53.         Serial.print(status, HEX);
  54.         Serial.print(" BIN:");
  55.         Serial.println(status, BIN);
  56.         if (PMU->isVbusInsertIrq()) {
  57.             Serial.println("isVbusInsert");
  58.         }
  59.         if (PMU->isVbusRemoveIrq()) {
  60.             Serial.println("isVbusRemove");
  61.         }
  62.         if (PMU->isBatInsertIrq()) {
  63.             Serial.println("isBatInsert");
  64.         }
  65.         if (PMU->isBatRemoveIrq()) {
  66.             Serial.println("isBatRemove");
  67.         }
  68.         if (PMU->isPekeyShortPressIrq()) {
  69.             Serial.println("isPekeyShortPress");
  70.         }
  71.         if (PMU->isPekeyLongPressIrq()) {
  72.             Serial.println("isPekeyLongPress");
  73.         }
  74.         if (PMU->isBatChagerDoneIrq()) {
  75.             Serial.println("isBatChagerDone");
  76.         }
  77.         if (PMU->isBatChagerStartIrq()) {
  78.             Serial.println("isBatChagerStart");
  79.         }
  80.         // Clear PMU Interrupt Status Register
  81.         PMU->clearIrqStatus();
  82.     }
  83.     //delay(3000);
  84.     // try to parse packet
  85.     int packetSize = LoRa.parsePacket();
  86.     if (packetSize)
  87.     {
  88.         // received a packet
  89.         //Serial.print("Received packet ");
  90.         String recv = "";
  91.         // read packet
  92.         while (LoRa.available())
  93.         {
  94.             recv += (char)LoRa.read();
  95.         }
  96.         //Serial.println(recv);
  97.         // print RSSI of packet
  98.         //Serial.print("' with RSSI: ");
  99.         //Serial.println(LoRa.packetRssi());
  100.         delay(10);
  101. #ifdef HAS_DISPLAY      
  102.         if (u8g2)
  103.         {      
  104.             u8g2->clearBuffer();
  105.             char buf[256];
  106.             u8g2->drawStr(0, 12, "Received OK!");
  107.             u8g2->setCursor(0, 25);
  108.             u8g2->print(PMU->getBattVoltage()); //u8g2->drawStr(0, 26, recv.c_str());
  109.             u8g2->println(" mV");
  110.             snprintf(buf, sizeof(buf), "RSSI:%i", LoRa.packetRssi());
  111.             u8g2->drawStr(0, 40, buf);
  112.             snprintf(buf, sizeof(buf), "SNR:%.1f", LoRa.packetSnr());
  113.             u8g2->drawStr(0, 56, buf);
  114.             while ( u8g2->nextPage() );
  115.             u8g2->sendBuffer();
  116.             u8g2->setFont(u8g2_font_fur11_tf);
  117.         }
  118.     }
  119. #endif
  120.      // This sketch displays information every time a new sentence is correctly encoded.
  121.     while (Serial1.available() > 0)
  122.         if (gps.encode(Serial1.read()))
  123.             displayInfo();
  124.             delay(1000);
  125. /*#ifdef HAS_DISPLAY
  126.     if (u8g2)
  127.     {
  128.         u8g2->clearBuffer();
  129.         do
  130.         {
  131.             u8g2->setCursor(0, 16);
  132.             u8g2->println( "Location.lat:");
  133.             u8g2->setCursor(0, 32);
  134.             u8g2->print(gps.location.lat(), 6);
  135.             u8g2->println(" deg");
  136.             u8g2->setCursor(0, 48);
  137.             u8g2->println( "Location.lng:");
  138.             u8g2->setCursor(0, 64);
  139.             u8g2->print(gps.location.lng(), 6);
  140.             u8g2->println(" deg");            
  141.         } while ( u8g2->nextPage() );
  142.         u8g2->sendBuffer();
  143.         u8g2->setFont(u8g2_font_fur11_tf);
  144.         delay(10);
  145.     }
  146. #endif
  147. #ifdef HAS_DISPLAY
  148.     if (u8g2)
  149.     {
  150.         u8g2->clearBuffer();
  151.         do
  152.         {
  153.             u8g2->setCursor(0, 16);
  154.             u8g2->print( "Hour:     ");
  155.             u8g2->println(gps.time.hour());
  156.             u8g2->setCursor(0, 32);
  157.             u8g2->print("minute:  ");
  158.             u8g2->println(gps.time.minute());
  159.             u8g2->setCursor(0, 48);
  160.             u8g2->print( "second:  ");
  161.             u8g2->println(gps.time.second());
  162.             u8g2->setCursor(0, 64);
  163.             u8g2->print("altitude: ");
  164.             u8g2->println(gps.altitude.meters());            
  165.         }
  166.         while ( u8g2->nextPage() );
  167.         u8g2->sendBuffer();
  168.         u8g2->setFont(u8g2_font_fur11_tf);
  169.         delay(3000);
  170.     }
  171. #endif*/
  172.     if (millis() > 5000 && gps.charsProcessed() < 10)
  173.     {
  174.         Serial.println(F("No GPS detected: check wiring."));
  175.         while (true);
  176.     }
  177. }
  178. void displayInfo()
  179. {
  180.     Serial.print(F("Location: "));
  181.     if (gps.location.isValid())
  182.     {
  183.         Serial.print(gps.location.lat(), 6);
  184.         Serial.print(F(","));
  185.         Serial.print(gps.location.lng(), 6);
  186.     } else
  187.     {
  188.         Serial.print(F("INVALID"));
  189.     }
  190.  
  191.     Serial.print(F("  Date/Time: "));
  192.     if (gps.date.isValid())
  193.     {
  194.         Serial.print(gps.date.month());
  195.         Serial.print(F("/"));
  196.         Serial.print(gps.date.day());
  197.         Serial.print(F("/"));
  198.         Serial.print(gps.date.year());
  199.     } else
  200.     {
  201.         Serial.print(F("INVALID"));
  202.     }
  203.  
  204.     Serial.print(F(" "));
  205.     if (gps.time.isValid())
  206.     {
  207.         if (gps.time.hour() < 10) Serial.print(F("0"));
  208.         Serial.print(gps.time.hour());
  209.         Serial.print(F(":"));
  210.         if (gps.time.minute() < 10) Serial.print(F("0"));
  211.         Serial.print(gps.time.minute());
  212.         Serial.print(F(":"));
  213.         if (gps.time.second() < 10) Serial.print(F("0"));
  214.         Serial.print(gps.time.second());
  215.         Serial.print(F("."));
  216.         if (gps.time.centisecond() < 10) Serial.print(F("0"));
  217.         Serial.print(gps.time.centisecond());
  218.     } else
  219.     {
  220.         Serial.print(F("INVALID"));
  221.     }
  222.  
  223.     Serial.println();
  224. }


boards
  1. String rssi = "RSSI --";
  2. String packSize = "--";
  3. String packet ;
  4. String message = "";
  5. #include <Arduino.h>
  6. #include <SPI.h>
  7. #include <Wire.h>
  8. #include "utilities.h"
  9. #ifdef HAS_DISPLAY
  10. #include <U8g2lib.h>
  11. #ifndef DISPLAY_MODEL
  12. #define DISPLAY_MODEL U8G2_SSD1306_128X64_NONAME_F_HW_I2C
  13. #endif
  14. DISPLAY_MODEL *u8g2 = nullptr;
  15. #endif
  16. #ifndef OLED_WIRE_PORT
  17. #define OLED_WIRE_PORT Wire
  18. #endif
  19. #if defined(HAS_PMU)
  20. #include "XPowersLib.h"
  21. XPowersLibInterface *PMU = NULL;
  22. #ifndef PMU_WIRE_PORT
  23. #define PMU_WIRE_PORT   Wire
  24. #endif
  25. bool pmuInterrupt;
  26. void setPmuFlag()
  27. {
  28.     pmuInterrupt = true;
  29. }
  30. bool initPMU()
  31. {
  32.     if (!PMU)
  33.     {
  34.         PMU = new XPowersAXP2101(PMU_WIRE_PORT);
  35.         if (!PMU->init()) {
  36.             Serial.println("Warning: Failed to find AXP2101 power management");
  37.             delete PMU;
  38.             PMU = NULL;
  39.         } else {
  40.             Serial.println("AXP2101 PMU init succeeded, using AXP2101 PMU");
  41.         }
  42.     }
  43.  
  44.     if (!PMU) {
  45.         PMU = new XPowersAXP192(PMU_WIRE_PORT);
  46.         if (!PMU->init()) {
  47.             Serial.println("Warning: Failed to find AXP192 power management");
  48.             delete PMU;
  49.             PMU = NULL;
  50.         } else {
  51.             Serial.println("AXP192 PMU init succeeded, using AXP192 PMU");
  52.         }
  53.     }
  54.  
  55.     if (!PMU) {
  56.         return false;
  57.     }
  58.  
  59.     PMU->setChargingLedMode(XPOWERS_CHG_LED_BLINK_1HZ);
  60.  
  61.     pinMode(PMU_IRQ, INPUT_PULLUP);
  62.     attachInterrupt(PMU_IRQ, setPmuFlag, FALLING);
  63.  
  64.     if (PMU->getChipModel() == XPOWERS_AXP192) {
  65.  
  66.         PMU->setProtectedChannel(XPOWERS_DCDC3);
  67.  
  68.         // lora
  69.         PMU->setPowerChannelVoltage(XPOWERS_LDO2, 3300);
  70.         // gps
  71.         PMU->setPowerChannelVoltage(XPOWERS_LDO3, 3300);
  72.         // oled
  73.         PMU->setPowerChannelVoltage(XPOWERS_DCDC1, 3300);
  74.  
  75.         PMU->enablePowerOutput(XPOWERS_LDO2);
  76.         PMU->enablePowerOutput(XPOWERS_LDO3);
  77.  
  78.         //protected oled power source
  79.         PMU->setProtectedChannel(XPOWERS_DCDC1);
  80.         //protected esp32 power source
  81.         PMU->setProtectedChannel(XPOWERS_DCDC3);
  82.         // enable oled power
  83.         PMU->enablePowerOutput(XPOWERS_DCDC1);
  84.  
  85.         //disable not use channel
  86.         PMU->disablePowerOutput(XPOWERS_DCDC2);
  87.  
  88.         PMU->disableIRQ(XPOWERS_AXP192_ALL_IRQ);
  89.  
  90.         PMU->enableIRQ(XPOWERS_AXP192_VBUS_REMOVE_IRQ |
  91.                        XPOWERS_AXP192_VBUS_INSERT_IRQ |
  92.                        XPOWERS_AXP192_BAT_CHG_DONE_IRQ |
  93.                        XPOWERS_AXP192_BAT_CHG_START_IRQ |
  94.                        XPOWERS_AXP192_BAT_REMOVE_IRQ |
  95.                        XPOWERS_AXP192_BAT_INSERT_IRQ |
  96.                        XPOWERS_AXP192_PKEY_SHORT_IRQ
  97.                       );
  98.  
  99.     } else if (PMU->getChipModel() == XPOWERS_AXP2101) {
  100.  
  101. #if defined(CONFIG_IDF_TARGET_ESP32)
  102.         //Unuse power channel
  103.         PMU->disablePowerOutput(XPOWERS_DCDC2);
  104.         PMU->disablePowerOutput(XPOWERS_DCDC3);
  105.         PMU->disablePowerOutput(XPOWERS_DCDC4);
  106.         PMU->disablePowerOutput(XPOWERS_DCDC5);
  107.         PMU->disablePowerOutput(XPOWERS_ALDO1);
  108.         PMU->disablePowerOutput(XPOWERS_ALDO4);
  109.         PMU->disablePowerOutput(XPOWERS_BLDO1);
  110.         PMU->disablePowerOutput(XPOWERS_BLDO2);
  111.         PMU->disablePowerOutput(XPOWERS_DLDO1);
  112.         PMU->disablePowerOutput(XPOWERS_DLDO2);
  113.  
  114.         // GNSS RTC PowerVDD 3300mV
  115.         PMU->setPowerChannelVoltage(XPOWERS_VBACKUP, 3300);
  116.         PMU->enablePowerOutput(XPOWERS_VBACKUP);
  117.  
  118.         //ESP32 VDD 3300mV
  119.         // ! No need to set, automatically open , Don't close it
  120.         // PMU->setPowerChannelVoltage(XPOWERS_DCDC1, 3300);
  121.         // PMU->setProtectedChannel(XPOWERS_DCDC1);
  122.         PMU->setProtectedChannel(XPOWERS_DCDC1);
  123.  
  124.         // LoRa VDD 3300mV
  125.         PMU->setPowerChannelVoltage(XPOWERS_ALDO2, 3300);
  126.         PMU->enablePowerOutput(XPOWERS_ALDO2);
  127.  
  128.         //GNSS VDD 3300mV
  129.         PMU->setPowerChannelVoltage(XPOWERS_ALDO3, 3300);
  130.         PMU->enablePowerOutput(XPOWERS_ALDO3);
  131.  
  132. #endif /*CONFIG_IDF_TARGET_ESP32*/
  133.  
  134.  
  135. #if defined(LILYGO_TBeamS3_SUPREME_V3_0)
  136.  
  137.         //t-beam m.2 inface
  138.         //gps
  139.         PMU->setPowerChannelVoltage(XPOWERS_ALDO4, 3300);
  140.         PMU->enablePowerOutput(XPOWERS_ALDO4);
  141.  
  142.         // lora
  143.         PMU->setPowerChannelVoltage(XPOWERS_ALDO3, 3300);
  144.         PMU->enablePowerOutput(XPOWERS_ALDO3);
  145.  
  146.         // In order to avoid bus occupation, during initialization, the SD card and QMC sensor are powered off and restarted
  147.         if (ESP_SLEEP_WAKEUP_UNDEFINED == esp_sleep_get_wakeup_cause()) {
  148.             Serial.println("Power off and restart ALDO BLDO..");
  149.             PMU->disablePowerOutput(XPOWERS_ALDO1);
  150.             PMU->disablePowerOutput(XPOWERS_ALDO2);
  151.             PMU->disablePowerOutput(XPOWERS_BLDO1);
  152.             delay(250);
  153.         }
  154.  
  155.         // Sensor
  156.         PMU->setPowerChannelVoltage(XPOWERS_ALDO1, 3300);
  157.         PMU->enablePowerOutput(XPOWERS_ALDO1);
  158.  
  159.         PMU->setPowerChannelVoltage(XPOWERS_ALDO2, 3300);
  160.         PMU->enablePowerOutput(XPOWERS_ALDO2);
  161.  
  162.         //Sdcard
  163.  
  164.         PMU->setPowerChannelVoltage(XPOWERS_BLDO1, 3300);
  165.         PMU->enablePowerOutput(XPOWERS_BLDO1);
  166.  
  167.         PMU->setPowerChannelVoltage(XPOWERS_BLDO2, 3300);
  168.         PMU->enablePowerOutput(XPOWERS_BLDO2);
  169.  
  170.         //face m.2
  171.         PMU->setPowerChannelVoltage(XPOWERS_DCDC3, 3300);
  172.         PMU->enablePowerOutput(XPOWERS_DCDC3);
  173.  
  174.         PMU->setPowerChannelVoltage(XPOWERS_DCDC4, XPOWERS_AXP2101_DCDC4_VOL2_MAX);
  175.         PMU->enablePowerOutput(XPOWERS_DCDC4);
  176.  
  177.         PMU->setPowerChannelVoltage(XPOWERS_DCDC5, 3300);
  178.         PMU->enablePowerOutput(XPOWERS_DCDC5);
  179.  
  180.  
  181.         //not use channel
  182.         PMU->disablePowerOutput(XPOWERS_DCDC2);
  183.         // PMU->disablePowerOutput(XPOWERS_DCDC4);
  184.         // PMU->disablePowerOutput(XPOWERS_DCDC5);
  185.         PMU->disablePowerOutput(XPOWERS_DLDO1);
  186.         PMU->disablePowerOutput(XPOWERS_DLDO2);
  187.         PMU->disablePowerOutput(XPOWERS_VBACKUP);
  188.  
  189.         // Set constant current charge current limit
  190.         PMU->setChargerConstantCurr(XPOWERS_AXP2101_CHG_CUR_500MA);
  191.  
  192.         // Set charge cut-off voltage
  193.         PMU->setChargeTargetVoltage(XPOWERS_AXP2101_CHG_VOL_4V2);
  194.  
  195.         // Disable all interrupts
  196.         PMU->disableIRQ(XPOWERS_AXP2101_ALL_IRQ);
  197.         // Clear all interrupt flags
  198.         PMU->clearIrqStatus();
  199.         // Enable the required interrupt function
  200.         PMU->enableIRQ(
  201.             XPOWERS_AXP2101_BAT_INSERT_IRQ    | XPOWERS_AXP2101_BAT_REMOVE_IRQ      |   //BATTERY
  202.             XPOWERS_AXP2101_VBUS_INSERT_IRQ   | XPOWERS_AXP2101_VBUS_REMOVE_IRQ     |   //VBUS
  203.             XPOWERS_AXP2101_PKEY_SHORT_IRQ    | XPOWERS_AXP2101_PKEY_LONG_IRQ       |   //POWER KEY
  204.             XPOWERS_AXP2101_BAT_CHG_DONE_IRQ  | XPOWERS_AXP2101_BAT_CHG_START_IRQ       //CHARGE
  205.             // XPOWERS_AXP2101_PKEY_NEGATIVE_IRQ | XPOWERS_AXP2101_PKEY_POSITIVE_IRQ   |   //POWER KEY
  206.         );
  207. #endif
  208.     }
  209.     PMU->enableSystemVoltageMeasure();
  210.     PMU->enableVbusVoltageMeasure();
  211.     PMU->enableBattVoltageMeasure();
  212.     // It is necessary to disable the detection function of the TS pin on the board
  213.     // without the battery temperature detection function, otherwise it will cause abnormal charging
  214.     PMU->disableTSPinMeasure();
  215.     Serial.printf("=========================================\n");
  216.     if (PMU->isChannelAvailable(XPOWERS_DCDC1))
  217.     {
  218.         Serial.printf("DC1  : %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_DCDC1)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_DCDC1));
  219.     }
  220.     if (PMU->isChannelAvailable(XPOWERS_DCDC2))
  221.     {
  222.         Serial.printf("DC2  : %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_DCDC2)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_DCDC2));
  223.     }
  224.     if (PMU->isChannelAvailable(XPOWERS_DCDC3))
  225.     {
  226.         Serial.printf("DC3  : %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_DCDC3)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_DCDC3));
  227.     }
  228.     if (PMU->isChannelAvailable(XPOWERS_DCDC4))
  229.     {
  230.         Serial.printf("DC4  : %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_DCDC4)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_DCDC4));
  231.     }
  232.     if (PMU->isChannelAvailable(XPOWERS_DCDC5))
  233.     {
  234.         Serial.printf("DC5  : %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_DCDC5)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_DCDC5));
  235.     }
  236.     if (PMU->isChannelAvailable(XPOWERS_LDO2)) {
  237.         Serial.printf("LDO2 : %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_LDO2)   ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_LDO2));
  238.     }
  239.     if (PMU->isChannelAvailable(XPOWERS_LDO3))
  240.     {
  241.         Serial.printf("LDO3 : %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_LDO3)   ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_LDO3));
  242.     }
  243.     if (PMU->isChannelAvailable(XPOWERS_ALDO1))
  244.     {
  245.         Serial.printf("ALDO1: %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_ALDO1)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_ALDO1));
  246.     }
  247.     if (PMU->isChannelAvailable(XPOWERS_ALDO2))
  248.     {
  249.         Serial.printf("ALDO2: %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_ALDO2)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_ALDO2));
  250.     }
  251.     if (PMU->isChannelAvailable(XPOWERS_ALDO3)) {
  252.         Serial.printf("ALDO3: %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_ALDO3)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_ALDO3));
  253.     }
  254.     if (PMU->isChannelAvailable(XPOWERS_ALDO4))
  255.     {
  256.         Serial.printf("ALDO4: %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_ALDO4)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_ALDO4));
  257.     }
  258.     if (PMU->isChannelAvailable(XPOWERS_BLDO1))
  259.     {
  260.         Serial.printf("BLDO1: %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_BLDO1)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_BLDO1));
  261.     }
  262.     if (PMU->isChannelAvailable(XPOWERS_BLDO2))
  263.     {
  264.         Serial.printf("BLDO2: %s   Voltage: %04u mV \n",  PMU->isPowerChannelEnable(XPOWERS_BLDO2)  ? "+" : "-",  PMU->getPowerChannelVoltage(XPOWERS_BLDO2));
  265.     }
  266.     Serial.printf("=========================================\n");
  267.     // Set the time of pressing the button to turn off
  268.     PMU->setPowerKeyPressOffTime(XPOWERS_POWEROFF_4S);
  269.     uint8_t opt = PMU->getPowerKeyPressOffTime();
  270.     Serial.print("PowerKeyPressOffTime:");
  271.     switch (opt)
  272.     {
  273.     case XPOWERS_POWEROFF_4S: Serial.println("4 Second");
  274.         break;
  275.     case XPOWERS_POWEROFF_6S: Serial.println("6 Second");
  276.         break;
  277.     case XPOWERS_POWEROFF_8S: Serial.println("8 Second");
  278.         break;
  279.     case XPOWERS_POWEROFF_10S: Serial.println("10 Second");
  280.         break;
  281.     default:
  282.         break;
  283.     }
  284.     return true;
  285. }
  286. void disablePeripherals()
  287. {
  288. }
  289. #else
  290. #define initPMU()
  291. #define disablePeripherals()
  292. #endif
  293. SPIClass SDSPI(HSPI);
  294. void initBoard()
  295. {
  296.     Serial.begin(115200);
  297.     Serial.println("initBoard");
  298.     SPI.begin(RADIO_SCLK_PIN, RADIO_MISO_PIN, RADIO_MOSI_PIN);
  299.     Wire.begin(I2C_SDA, I2C_SCL);
  300. #ifdef I2C1_SDA
  301.     Wire1.begin(I2C1_SDA, I2C1_SCL);
  302. #endif
  303. #ifdef RADIO_TCXO_EN_PIN
  304.     pinMode(RADIO_TCXO_EN_PIN, OUTPUT);
  305.     digitalWrite(RADIO_TCXO_EN_PIN, HIGH);
  306. #endif
  307. #ifdef HAS_GPS
  308.     Serial1.begin(GPS_BAUD_RATE, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
  309. #endif
  310. #if OLED_RST
  311.     pinMode(OLED_RST, OUTPUT);
  312.     digitalWrite(OLED_RST, HIGH); delay(20);
  313.     digitalWrite(OLED_RST, LOW);  delay(20);
  314.     digitalWrite(OLED_RST, HIGH); delay(20);
  315. #endif
  316.     initPMU();
  317. #ifdef BOARD_LED
  318.     /*
  319.     * T-BeamV1.0, V1.1 LED defaults to low level as trun on,
  320.     * so it needs to be forced to pull up
  321.     * * * * */
  322. #if LED_ON == LOW
  323.     gpio_hold_dis(GPIO_NUM_4);
  324. #endif
  325.     pinMode(BOARD_LED, OUTPUT);
  326.     digitalWrite(BOARD_LED, LED_ON);
  327. #endif
  328. #ifdef HAS_DISPLAY
  329.     Wire.beginTransmission(0x3C);
  330.     if (Wire.endTransmission() == 0)
  331.     {
  332.         Serial.println("Started OLED");
  333.         u8g2 = new DISPLAY_MODEL(U8G2_R0, U8X8_PIN_NONE);
  334.         u8g2->begin();
  335.         u8g2->clearBuffer();
  336.         u8g2->setFlipMode(0);
  337.         u8g2->setFontMode(1); // Transparent
  338.         u8g2->setDrawColor(1);
  339.         u8g2->setFontDirection(0);
  340.         u8g2->firstPage();
  341.         do {
  342.             u8g2->setFont(u8g2_font_inb19_mr);
  343.             u8g2->drawStr(0, 30, "LilyGo");
  344.             u8g2->drawHLine(2, 35, 47);
  345.             u8g2->drawHLine(3, 36, 47);
  346.             u8g2->drawVLine(45, 32, 12);
  347.             u8g2->drawVLine(46, 33, 12);
  348.             u8g2->setFont(u8g2_font_inb19_mf);
  349.             u8g2->drawStr(58, 60, "LoRa");
  350.         } while ( u8g2->nextPage() );
  351.         u8g2->sendBuffer();
  352.         u8g2->setFont(u8g2_font_fur11_tf);
  353.         delay(3000);
  354.     }
  355. #endif
  356. #ifdef HAS_DISPLAY
  357.     if (u8g2)
  358.     {
  359.         u8g2->clearBuffer();
  360.         do
  361.         {
  362.             u8g2->setCursor(0, 16);
  363.             u8g2->println( "BattVoltage:");
  364.             u8g2->setCursor(0, 32);
  365.             u8g2->print(PMU->getBattVoltage());
  366.             u8g2->println("mV");
  367.         } while ( u8g2->nextPage() );
  368.         u8g2->sendBuffer();
  369.         u8g2->setFont(u8g2_font_fur11_tf);
  370.         delay(3000);
  371.     }
  372. #endif
  373. }


utilities
  1. #pragma once
  2. #define LILYGO_TBeam_V1_X
  3. #ifndef LoRa_frequency
  4. #define LoRa_frequency      433E6
  5. #endif
  6. #if defined(LILYGO_TBeam_V1_X)
  7. #define GPS_RX_PIN                  34
  8. #define GPS_TX_PIN                  12
  9. #define BUTTON_PIN                  38
  10. #define BUTTON_PIN_MASK             GPIO_SEL_38
  11. #define I2C_SDA                     21
  12. #define I2C_SCL                     22
  13. #define PMU_IRQ                     35
  14.  
  15. #define RADIO_SCLK_PIN               5
  16. #define RADIO_MISO_PIN              19
  17. #define RADIO_MOSI_PIN              27
  18. #define RADIO_CS_PIN                18
  19. #define RADIO_DIO0_PIN               26
  20. #define RADIO_RST_PIN               23
  21. #define RADIO_DIO1_PIN              33
  22. #define RADIO_BUSY_PIN              32
  23.  
  24. #define BOARD_LED                   4
  25. #define LED_ON                      LOW
  26. #define LED_OFF                     HIGH
  27.  
  28. #define GPS_BAUD_RATE               9600
  29. #define HAS_GPS
  30. #define HAS_DISPLAY                 //Optional, bring your own board, no OLED !!
  31. #define HAS_PMU
  32.  
  33. #else
  34. #error "For the first use, please define the board version and model in <utilities. h>"
  35. #endif
(#) hadhazik válasza hadhazik hozzászólására (») Nov 20, 2023 /
 
Alakul, viszont egyre hosszabb intervallumokban frissül, lehet state lesz a jobb megoldás, vagy a millis is újraindítható?
  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;
  10. uint32_t start2Millis;
  11. uint32_t start3Millis;
  12. uint32_t start4Millis;
  13. uint32_t start5Millis;
  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.     if (millis() > start1Millis)
  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 += millis() + 10;
  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(millis()> start2Millis)
  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 += millis() + 20;
  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(millis()> start3Millis)      
  131.             {
  132.             displayInfo();
  133.             start3Millis += millis() + 30;
  134.             }
  135. if(millis()> start4Millis)
  136. {
  137. #ifdef HAS_DISPLAY
  138.     if (u8g2)
  139.     {
  140.         u8g2->clearBuffer();
  141.         do
  142.         {
  143.             u8g2->setCursor(0, 16);
  144.             u8g2->println( "Location.lat:");
  145.             u8g2->setCursor(0, 32);
  146.             u8g2->print(gps.location.lat(), 6);
  147.             u8g2->println(" deg");
  148.             u8g2->setCursor(0, 48);
  149.             u8g2->println( "Location.lng:");
  150.             u8g2->setCursor(0, 64);
  151.             u8g2->print(gps.location.lng(), 6);
  152.             u8g2->println(" deg");            
  153.         } while ( u8g2->nextPage() );
  154.         u8g2->sendBuffer();
  155.         u8g2->setFont(u8g2_font_fur11_tf);
  156.             start4Millis += millis() + 40;
  157.     }
  158. #endif
  159. }
  160. if(millis()> start5Millis)
  161. {
  162.   #ifdef HAS_DISPLAY
  163.     if (u8g2)
  164.     {
  165.         u8g2->clearBuffer();
  166.         do
  167.         {
  168.             u8g2->setCursor(0, 16);
  169.             u8g2->print( "Hour:     ");
  170.             u8g2->println(gps.time.hour());
  171.             u8g2->setCursor(0, 32);
  172.             u8g2->print("minute:  ");
  173.             u8g2->println(gps.time.minute());
  174.             u8g2->setCursor(0, 48);
  175.             u8g2->print( "second:  ");
  176.             u8g2->println(gps.time.second());
  177.             u8g2->setCursor(0, 64);
  178.             u8g2->print("altitude: ");
  179.             u8g2->println(gps.altitude.meters());            
  180.         }
  181.         while ( u8g2->nextPage() );
  182.         u8g2->sendBuffer();
  183.         u8g2->setFont(u8g2_font_fur11_tf);
  184.             start5Millis += millis() + 50;
  185.     }
  186. #endif
  187. }
  188.     if (millis() > 5000 && gps.charsProcessed() < 10)
  189.     {
  190.         Serial.println(F("No GPS detected: check wiring."));
  191.         while (true);
  192.     }
  193. }
  194. void displayInfo()
  195. {
  196.     Serial.print(F("Location: "));
  197.     if (gps.location.isValid())
  198.     {
  199.         Serial.print(gps.location.lat(), 6);
  200.         Serial.print(F(","));
  201.         Serial.print(gps.location.lng(), 6);
  202.     } else
  203.     {
  204.         Serial.print(F("INVALID"));
  205.     }
  206.  
  207.     Serial.print(F("  Date/Time: "));
  208.     if (gps.date.isValid())
  209.     {
  210.         Serial.print(gps.date.month());
  211.         Serial.print(F("/"));
  212.         Serial.print(gps.date.day());
  213.         Serial.print(F("/"));
  214.         Serial.print(gps.date.year());
  215.     } else
  216.     {
  217.         Serial.print(F("INVALID"));
  218.     }
  219.  
  220.     Serial.print(F(" "));
  221.     if (gps.time.isValid())
  222.     {
  223.         if (gps.time.hour() < 10) Serial.print(F("0"));
  224.         Serial.print(gps.time.hour());
  225.         Serial.print(F(":"));
  226.         if (gps.time.minute() < 10) Serial.print(F("0"));
  227.         Serial.print(gps.time.minute());
  228.         Serial.print(F(":"));
  229.         if (gps.time.second() < 10) Serial.print(F("0"));
  230.         Serial.print(gps.time.second());
  231.         Serial.print(F("."));
  232.         if (gps.time.centisecond() < 10) Serial.print(F("0"));
  233.         Serial.print(gps.time.centisecond());
  234.     } else
  235.     {
  236.         Serial.print(F("INVALID"));
  237.     }
  238.  
  239.     Serial.println();
  240. }
  241. ```
A hozzászólás módosítva: Nov 20, 2023
(#) hadhazik válasza hadhazik hozzászólására (») Nov 20, 2023 /
 
20:40:13:00
20:40:21:00
20:40:29:00
20:40:46:00
20:41:20:00
20:42:27:00
20:44:42:00
20:49:11:00
20:58:10:00
21:16:07:00
(#) Pethical válasza scooby_ hozzászólására (») Nov 21, 2023 /
 
Örülök, az ESP kódban is felcseréltem a két végponot, most látom, de sebaj, Örülök, hogy segített
(#) Keresztes Vitéz hozzászólása Nov 21, 2023 /
 
Sziasztok! Egy projekt elején vagyok, de a megvalósíthatóságában kételkedem.
Egy 2-tengelyes, léptetőmotoros mechanikát kellene építenem. Mindkét tengelyen nagy sebességkülönbségeket, felbontást kell lehetővé tenni. A mikrovezérlő Atmega328, a léptetőmotor vezérlő pedig TMC2208 lenne, ami "legacy" módban csak 1/16 mikrolépést tesz lehetővé, ami kevés. Lehetőség van UART-on keresztül nagyobb felbontást elérni és itt jön a kételyem; lehetséges mindkét léptetőmotor vezérlőjét külön megcímezni UART-on keresztül, és ha igen, mi a módja?
Azért van erre szükség, mert előfordulhat, hogy míg az egyik tengely nyugodtan száguldozhat akár 1/2 mikrolépéssel, addig a másiknak 1/64 mikrolépéssel kellene mozognia.
Tudom, használhatnék más léptetőmotor vezérlőt, ami UART nélkül is több mikrolépés lehetőséget kínál, de a TMC2208 mind közül a leghalkabb, ami most fontos lenne. (Már épült egy mechanika DRV8825 vezérlőkkel, de borzasztó hangos.)
Köszönöm a választ, segítséget!
(#) kapu48 válasza Keresztes Vitéz hozzászólására (») Nov 21, 2023 /
 
Miért ezt az elavult 8 bitest választottad?
Mikor jóval korszerűbb mindenben jobb. És legalább van benne 2db. soros port is.
Bővebben: Link STM32F103
(#) Keresztes Vitéz válasza kapu48 hozzászólására (») Nov 21, 2023 /
 
Azért ezt választottam, mert ez öröklődött a projekt előzményéből, és mert ezzel van tapasztalat, valamint eddig elég is volt a feladatra.
(#) kapu48 válasza Keresztes Vitéz hozzászólására (») Nov 21, 2023 / 1
 
Itt találsz segítséget: Bővebben: Link
(#) Pethical válasza Keresztes Vitéz hozzászólására (») Nov 21, 2023 /
 
Sajnos a külön vezérlők nem címezhetők, dedikált soros kommunikáció kell nekik.
Vagy beírod az OTP-be az értékeket és akkor nem kell vesződni UART-tal (de csak 1x írható valóban), vagy a SoftwareSerial lehet még segítségedre.
(#) Keresztes Vitéz válasza Pethical hozzászólására (») Nov 21, 2023 /
 
Ez nagyon hasznos, köszönöm!
Igen, az OTP jó lenne, de mivel menet közben kellene variálni a mikrolépést, így ez kiesik.
(#) kapu48 válasza Keresztes Vitéz hozzászólására (») Nov 21, 2023 /
 
A "SoftwareSerial" is kiesik mert ehhez lassú lesz neked!
(#) vargham válasza kapu48 hozzászólására (») Nov 21, 2023 /
 
Marad a mikrokontroller csere.
(#) Keresztes Vitéz válasza kapu48 hozzászólására (») Nov 21, 2023 /
 
Nem feltételnül. A
Idézet:
„menet közben kellene variálni a mikrolépést”
úgy értem, hogy a program futása közben. Viszont amikor át kell állítani a mikrolépést, akkor egyik tengely sem mozog, és a várakozás nem olyan időérzékeny, szóval működhet.
(#) pipi válasza Keresztes Vitéz hozzászólására (») Nov 21, 2023 /
 
Hali!
Mi akadályoz meg hogy pár ttl kapuból megcsináld a soros port átkapcsolását a két tmc között?
(#) Pethical válasza Keresztes Vitéz hozzászólására (») Nov 21, 2023 /
 
Annak mi az oka, hogy menet közben szeretnéd a mikrolépést állítani?
Ezekre szükség lehet! - HESTORE.HU

ATMEGA328P-AU
DRV8825-M
ESP32-C3-DEVKITM-1
ESP8266-BURN
BS-800-N
Következő: »»   823 / 850
Bejelentkezés

Belépés
Hirdetés
XDT.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