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   821 / 845
(#) asch válasza MATA hozzászólására (») Okt 31, 2023 /
 
Az csak azt jelenti, hogy abban a függvényben van a hiba. De nem a neve a rossz, hanem az a sor, amit idéztél is. Ez a helyes változat az adatlap alapján (nem próbálom ki):
  1. ADCSRA = (1<<ADEN) | (1<<ADIE) | (1<<ADATE) | (1<<ADIF) | (1<<ADSC) |
(#) MATA válasza asch hozzászólására (») Okt 31, 2023 /
 
Hoppá és működik nagyon köszönöm nem is gondoltam volna Atmega328-al megy most hogyan hogy csak ennyi volt a gond és megy ezzel is nem semmi!
(#) asch válasza MATA hozzászólására (») Okt 31, 2023 /
 
Gratulálok! Foglalatban volt eleve a csip? És volt kéznél 328-as? Gyorsan ment a csere.
(#) MATA válasza asch hozzászólására (») Okt 31, 2023 /
 
Hihetetlen mi pedig itt a bizonyíték rá.
Persze foglalatban volt mindíg abba teszem.

IMG_20231031...jpg
IMG_20231031...jpg		   
(#) hadhazik hozzászólása Nov 3, 2023 /
 
Az alábbi kódhoz kérnék segítséget.
A LoRa modulok között folyó csomag fogadáskor serialon kiíratom a fogadott adatokat, oled kijelzőn
"HELLO" szöveget és kettő hőfok adatot. A csomagok fogadásának folyamatosan kell működnie, a kijelzőt frissíteni az új adatokkal. A frissítés ne tegye olvashatatlanná a kijelzőt a túl rövid megjelenítéssel.
Delay(); beszúrással most minden 5. csomagot fogadja a vevő LoRa, 1000ms-ig megjelenítve az oleden.
Millis vagy állapotgép irányba próbáljak tovább lépni?
  1. ```cpp
  2.  
  3. #include <Wire.h>
  4. const char* ssid     = "xxxx";
  5. const char* password = "1111";
  6. const char* ntpServer = "hu.pool.ntp.org";
  7. const long  gmtOffset_sec = 0;
  8. const int   daylightOffset_sec = 3600;
  9. #include <Arduino.h>
  10. #include <Wire.h>  
  11. #include <WiFi.h>
  12. #include <Timer.h>
  13. #include <SPI.h>
  14. #include <LoRa.h>
  15. uint16_t writecount;
  16. uint32_t startwritemS, endwritemS, timemS;
  17. #define SCK     18    // GPIO5  -- SX1278's SCK
  18. #define MISO    19   // GPIO19 -- SX1278's MISO
  19. #define MOSI    23   // GPIO27 -- SX1278's MOSI
  20. #define SS      5   // GPIO18 -- SX1278's CS
  21. #define RST     4   // GPIO14 -- SX1278's RESET
  22. #define DI0     26   // GPIO26 -- SX1278's IRQ(Interrupt Request)
  23. #define BAND    433E6
  24. unsigned int state = 0;
  25. unsigned int counter = 0;
  26. String rssi = "RSSI --";
  27. String packSize = "--";
  28. String packet ;
  29. struct tm timeinfo;
  30. static char msg[20]; // character buffer
  31. #include <Adafruit_GFX.h>
  32. #include <Adafruit_SSD1306.h>
  33.  
  34. #define SCREEN_WIDTH 128 // OLED display width, in pixels
  35. #define SCREEN_HEIGHT 64 // OLED display height, in pixels
  36.  
  37. // Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
  38. #define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
  39. Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
  40. #include <StateMachine.h>
  41. const int STATE_DELAY = 10;
  42. int randomState = 0;
  43. const int LED = 13;
  44. StateMachine machine = StateMachine();
  45. State* S0 = machine.addState(&state0);
  46. State* S1 = machine.addState(&state1);
  47. void setup()
  48. {
  49.  Serial.begin(115200);
  50.    while (!Serial);
  51.   if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C))
  52.   {
  53.     Serial.println(F("SSD1306 allocation failed"));
  54.     for(;;); // Don't proceed, loop forever
  55.   }
  56.   display.display();
  57.   delay(2000); // Pause for 2 seconds
  58.  
  59.   // Clear the buffer
  60.   display.clearDisplay();
  61.  Wire.begin();
  62.  Serial.setDebugOutput(true);
  63.  Serial.print("Connecting to ");
  64.  Serial.print(ssid);
  65.  WiFi.begin(ssid, password);
  66.  while (WiFi.status() != WL_CONNECTED) {
  67.  delay(500);
  68.  Serial.print(".");
  69.  }
  70.   Serial.println("");
  71.   Serial.println("WiFi connected.");
  72.    // Init and get the time
  73.  
  74.   configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  75.   printLocalTime();
  76.  
  77.  Serial.println();
  78.  Serial.print("Connected! IP address: ");
  79.  Serial.println(WiFi.localIP());
  80.   //disconnect WiFi as it's no longer needed
  81.   WiFi.disconnect(true);
  82.   WiFi.mode(WIFI_OFF);
  83.   SPI.begin(SCK,MISO,MOSI,SS);
  84.   LoRa.setPins(5,4,26);
  85.   Serial.println("LoRa Receiver");
  86.   if (!LoRa.begin(433E6)) {
  87.     Serial.println("Starting LoRa failed!");
  88.     while (1);
  89.   }
  90.   Serial.println("init ok");
  91.   display.invertDisplay(true);
  92.   delay(1000);
  93.   display.invertDisplay(false);
  94.   delay(1000);
  95.   display.clearDisplay();
  96.   randomSeed(A0);
  97.   S0->addTransition(&transitionS0S1,S1);    // Transition to itself
  98.   S1->addTransition(&transitionS1S0,S0);  //(see transition logic for details)
  99. }
  100.  
  101. void loop()
  102. {
  103.   machine.run();
  104.   delay(STATE_DELAY);
  105. }
  106. //=======================================
  107. void state0(){
  108.     int packetSize = LoRa.parsePacket();
  109.     String message = "";
  110.     if (packetSize)
  111.     {  // received a packet
  112.          Serial.print("Received packet :");    
  113.         while (LoRa.available())
  114.         {
  115.          message += (char)LoRa.read();
  116.         }
  117.          Serial.print(message);
  118.         // print RSSI of packet    
  119.          Serial.print("' with RSSI ");    
  120.          Serial.println(LoRa.packetRssi());
  121.          Serial.print("Status: ");
  122.          Serial.println(message.charAt(0));
  123.         if (message.charAt(0) == '0')
  124.         {
  125.          Serial.println(" GAZ_KAZAN");
  126.         }
  127.        else
  128.         {
  129.          Serial.println("BOILER");
  130.          delay(50);
  131.         }
  132.     }
  133.   display.setTextSize(2);             // Normal 1:1 pixel scale
  134.   display.setTextColor(WHITE);        // Draw white text
  135.   display.setCursor(0,0);  
  136.   display.print(message.charAt(3));
  137.   display.print(message.charAt(4));
  138.   display.print(message.charAt(5));
  139.   display.print(message.charAt(6));
  140.   display.print(message.charAt(7));
  141.   display.println(message.charAt(8));
  142.   display.setTextSize(3);             // Normal 1:1 pixel scale
  143.   display.setTextColor(WHITE);        // Draw white text
  144.   display.print(message.charAt(9));
  145.   display.print(message.charAt(10));
  146.   display.print(message.charAt(11));
  147.   display.print(message.charAt(12));
  148.   display.print(message.charAt(13));
  149.   display.println(message.charAt(14));
  150.   display.print(message.charAt(15));
  151.   display.print(message.charAt(16));
  152.   display.print(message.charAt(17));
  153.   display.print(message.charAt(18));
  154.   display.print(message.charAt(19));
  155.   display.print(message.charAt(20));
  156.   display.println(message.charAt(21));
  157.   display.display();
  158. }
  159. bool transitionS0S1(){
  160.   return true;
  161. }
  162. void state1()
  163. {
  164. delay(1000);  
  165. display.clearDisplay();
  166. }
  167. bool transitionS1S0(){
  168.   return true;
  169. }
  170. void printLocalTime(){
  171.   struct tm timeinfo;
  172.   if(!getLocalTime(&timeinfo)){
  173.     Serial.println("Failed to obtain time");
  174.     return;
  175.   }
  176.   Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
  177.   Serial.print("Day of week: ");
  178.   Serial.println(&timeinfo, "%A");
  179.   Serial.print("Month: ");
  180.   Serial.println(&timeinfo, "%B");
  181.   Serial.print("Day of Month: ");
  182.   Serial.println(&timeinfo, "%d");
  183.   Serial.print("Year: ");
  184.   Serial.println(&timeinfo, "%Y");
  185.   Serial.print("Hour: ");
  186.   Serial.println(&timeinfo, "%H");
  187.   Serial.print("Hour (12 hour format): ");
  188.   Serial.println(&timeinfo, "%I");
  189.   Serial.print("Minute: ");
  190.   Serial.println(&timeinfo, "%M");
  191.   Serial.print("Second: ");
  192.   Serial.println(&timeinfo, "%S");
  193.   Serial.println("Time variables");
  194.   char timeHour[3];
  195.   strftime(timeHour,3, "%H", &timeinfo);
  196.   Serial.println(timeHour);
  197.   char timeWeekDay[10];
  198.   strftime(timeWeekDay,10, "%A", &timeinfo);
  199.   Serial.println(timeWeekDay);
  200.   Serial.println();
  201. }
  202. ```
(#) Balagemann2031 hozzászólása Nov 4, 2023 /
 
Sziasztok!
Szeretnék egy kis segítséget kérni! Elakadtam egy 128x32-es oled I2C-s kijelző inicializálásánál. Nem tudom életre kelteni. SPI-s kijelzővel nincs bajom, azt tudom kezelni. A kijelzőt SSD1306 vezérlő kezeli, ennek az adatlapjában, ahol az i2c írást mutatják, csak /slave address/ után a
/control byte/-/data byte/ ismétlődik, így az alábbi kóddal próbálkozom a parancsokat küldeni:
  1. void oledCommand1(uint8_t command) {
  2.   Wire.beginTransmission(OLED_ADDRESS);
  3.   Wire.write(0x00);  // Co = 0, D/C = 0
  4.   Wire.write(command);
  5.   Wire.endTransmission();
  6. }


Van esetleg valakinek egy működő I2C-s init-je? Vagy több bájtos parancs küldő algoritmusa? Segítséget előre is köszönöm! Még annyi, hogy adafruit meg hasonló könyvtárakkal nem szeretném megoldani, magam szeretném majd megírni, ha sikerül elindulni vele.
A hozzászólás módosítva: Nov 4, 2023
(#) Balagemann2031 válasza Balagemann2031 hozzászólására (») Nov 4, 2023 /
 
Rájöttem közben, 0x00 helyett 0x80 kell és megy.
(#) asch válasza hadhazik hozzászólására (») Nov 6, 2023 /
 
Én úgy csinálnám, hogy két állapotgép lenne, az egyik a LORA adatok vétele, a másik a megjelenítés. Az adatokból a legújabbat tárolná le a LORA vevő egy static függvényen kívüli változóba. A megjelenítő pedig mondjuk másodpercenként frissülne, és mindig az aktuálisat írná ki pont úgy, ahogy most is implementálva van. Delayt nem használnék, hanem időzítő alapú állapotátmenettel valósítanám meg. Tehát a rajzoló állapotgépben mondjuk másodpercenként mennék a refresh állapotba, majd onnan az újrarajzolás után a sleep állapotba.

Az állapotgép vagy a loop-ba kézzel beírt akciók ekvivalensek. Ha már egyszer bevetted ezt az állapotgépes libet, akkor már ezzel oldanám meg feltéve, hogy sikerül megvalósítani a célt. De ugyanezt meg lehet csinálni úgy is, hogy számontartod, hogy melyik milli()-ben volt az utolsó rajzolás és ha eltelt 1000, akkor rajzolsz újra.

A program Wifis része újracsatlakozik magától, ha esetleg leszakad valami miatt? Ha nem, akkor még erre is csinálnék egy állapotgépet.
(#) hadhazik válasza asch hozzászólására (») Nov 6, 2023 /
 
  1. ```cpp
  2. /*esp2 module,wifi,LoRa,0.96 oled
  3. Jelenleg így módosítottam a kódot.
  4. Setupban a void loraserial nem fut le a többi rész igen.
  5. Loopban a beállított delay időkig megjeleníti a kijelzéseket.
  6. Ami érdekes. egy ideig csak "RSSI -164" kerül kijelzésre, aztán felváltva "RSSI -88" és "HELLO 37.00 19.00"*/
  7. #include <Wire.h>
  8. const char* ssid     = "xxxx";
  9. const char* password = "xxxx";
  10. const char* ntpServer = "hu.pool.ntp.org";
  11. const long  gmtOffset_sec = 0;
  12. const int   daylightOffset_sec = 3600;
  13. #include <Arduino.h>
  14. #include <Wire.h>  
  15. #include <WiFi.h>
  16. #include <Timer.h>
  17. #include <SPI.h>
  18. #include <LoRa.h>
  19. #define SCK     18    // GPIO5  -- SX1278's SCK
  20. #define MISO    19   // GPIO19 -- SX1278's MISO
  21. #define MOSI    23   // GPIO27 -- SX1278's MOSI
  22. #define SS      5   // GPIO18 -- SX1278's CS
  23. #define RST     4   // GPIO14 -- SX1278's RESET
  24. #define DI0     26   // GPIO26 -- SX1278's IRQ(Interrupt Request)
  25. #define BAND    433E6
  26. unsigned int state = 0;
  27. unsigned int counter = 0;
  28. String rssi = "RSSI --";
  29. String packSize = "--";
  30. String packet ;
  31. String message = "";
  32. struct tm timeinfo;
  33. static char msg[20]; // character buffer
  34. #include <Adafruit_GFX.h>
  35. #include <Adafruit_SSD1306.h>
  36. #define SCREEN_WIDTH 128 // OLED display width, in pixels
  37. #define SCREEN_HEIGHT 64 // OLED display height, in pixels
  38. // Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
  39. #define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
  40. Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
  41. void setup()
  42. {
  43.  Serial.begin(115200);
  44.    while (!Serial);
  45.   if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C))
  46.   {
  47.     Serial.println(F("SSD1306 allocation failed"));
  48.     for(;;); // Don't proceed, loop forever
  49.   }
  50.   display.display();
  51.   delay(2000); // Pause for 2 seconds
  52.  Wire.begin();
  53.  Serial.setDebugOutput(true);
  54.  Serial.print("Connecting to ");
  55.  Serial.print(ssid);
  56.  WiFi.begin(ssid, password);
  57.  while (WiFi.status() != WL_CONNECTED) {
  58.  delay(500);
  59.  Serial.print(".");
  60.  }
  61.   Serial.println("");
  62.   Serial.println("WiFi connected.");
  63.    // Init and get the time
  64.   configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  65.   printLocalTime();
  66.  Serial.println();
  67.  Serial.print("Connected! IP address: ");
  68.  Serial.println(WiFi.localIP());
  69.   //disconnect WiFi as it's no longer needed
  70.   WiFi.disconnect(true);
  71.   WiFi.mode(WIFI_OFF);
  72.   lorastart();
  73.   loraserial();
  74.   delay(2000);
  75.   display.invertDisplay(true);
  76.   delay(1000);
  77.   display.invertDisplay(false);
  78.   delay(1000);
  79. }
  80. void loop()
  81. {    
  82. oledstart();
  83. charoled();
  84. rssioled();
  85. }
  86. //=======================================
  87. void lorastart()
  88. {
  89.   SPI.begin(SCK,MISO,MOSI,SS);
  90.   LoRa.setPins(5,4,26);
  91.   Serial.println("LoRa Receiver");
  92.   if (!LoRa.begin(433E6))
  93.   {
  94.     Serial.println("Starting LoRa failed!");
  95.     while (1);
  96.   }
  97.   Serial.println("init ok");
  98. }
  99. void oledstart()
  100. {    
  101.   int packetSize = LoRa.parsePacket();
  102.     if (packetSize)
  103.     {  // received a packet    
  104.         while (LoRa.available())
  105.         {
  106.          message += (char)LoRa.read();
  107.         }
  108.     }
  109. }
  110. void loraserial()
  111. {
  112.     int packetSize = LoRa.parsePacket();
  113.     if (packetSize)
  114.     {  // received a packet
  115.          Serial.print("Received packet :");    
  116.         while (LoRa.available())
  117.         {
  118.          message += (char)LoRa.read();
  119.         }
  120.          Serial.print(message);
  121.         // print RSSI of packet    
  122.          Serial.print(" with RSSI ");    
  123.          Serial.println(LoRa.packetRssi());
  124.          Serial.print("Status: ");
  125.          Serial.println(message.charAt(0));
  126.         if (message.charAt(0) == '0')
  127.         {
  128.          Serial.println(" GAZ_KAZAN");
  129.         }
  130.        else
  131.         {
  132.          Serial.println("BOILER");
  133.         }
  134.     }
  135. }
  136. void charoled()
  137. {
  138.   display.clearDisplay();
  139.   display.setTextSize(2);             // Normal 1:1 pixel scale
  140.   display.setTextColor(WHITE);        // Draw white text
  141.   display.setCursor(0,0);  
  142.   display.print(message.charAt(3));
  143.   display.print(message.charAt(4));
  144.   display.print(message.charAt(5));
  145.   display.print(message.charAt(6));
  146.   display.print(message.charAt(7));
  147.   display.println(message.charAt(8));
  148.   display.setTextSize(3);             // Normal 1:1 pixel scale
  149.   display.setTextColor(WHITE);        // Draw white text
  150.   display.print(message.charAt(9));
  151.   display.print(message.charAt(10));
  152.   display.print(message.charAt(11));
  153.   display.print(message.charAt(12));
  154.   display.print(message.charAt(13));
  155.   display.println(message.charAt(14));
  156.   display.print(message.charAt(15));
  157.   display.print(message.charAt(16));
  158.   display.print(message.charAt(17));
  159.   display.print(message.charAt(18));
  160.   display.print(message.charAt(19));
  161.   display.print(message.charAt(20));
  162.   display.println(message.charAt(21));
  163.   display.display();
  164.   delay(2000);
  165. }
  166. void rssioled()
  167. {
  168.   display.clearDisplay();
  169.   display.setTextSize(4);             // Normal 1:1 pixel scale
  170.   display.setTextColor(WHITE);        // Draw white text
  171.   display.setCursor(0,0);  
  172.   display.println("RSSI ");
  173.   display.print(LoRa.packetRssi());
  174.   display.display();
  175.   delay(2000);
  176. }
  177. void printLocalTime()
  178. {
  179.   struct tm timeinfo;
  180.   if(!getLocalTime(&timeinfo))
  181.   {
  182.     Serial.println("Failed to obtain time");
  183.     return;
  184.   }
  185.   Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
  186.   Serial.print("Day of week: ");
  187.   Serial.println(&timeinfo, "%A");
  188.   Serial.print("Month: ");
  189.   Serial.println(&timeinfo, "%B");
  190.   Serial.print("Day of Month: ");
  191.   Serial.println(&timeinfo, "%d");
  192.   Serial.print("Year: ");
  193.   Serial.println(&timeinfo, "%Y");
  194.   Serial.print("Hour: ");
  195.   Serial.println(&timeinfo, "%H");
  196.   Serial.print("Hour (12 hour format): ");
  197.   Serial.println(&timeinfo, "%I");
  198.   Serial.print("Minute: ");
  199.   Serial.println(&timeinfo, "%M");
  200.   Serial.print("Second: ");
  201.   Serial.println(&timeinfo, "%S");
  202.   Serial.println("Time variables");
  203.   char timeHour[3];
  204.   strftime(timeHour,3, "%H", &timeinfo);
  205.   Serial.println(timeHour);
  206.   char timeWeekDay[10];
  207.   strftime(timeWeekDay,10, "%A", &timeinfo);
  208.   Serial.println(timeWeekDay);
  209.   Serial.println();
  210. }
  211. ```
(#) hadhazik válasza hadhazik hozzászólására (») Nov 8, 2023 /
 
A wifi működik, a LoRa vevő úgy tűnik megdöglött, van egy másik modul, abban tökéletesen fut a rá írt kód. Hamarosan érkezik egy Meshtastic T-Beam ESP32 LoRa 433 szintén a Lilygo-tól.
Remélem az tovább bírja.
(#) antikzsolt hozzászólása Nov 8, 2023 /
 
Üdv.

Ma jött meg az arduino unom. A tanulásban viszont utolértem magam és szeretnék egy kicsit előre haladni. Az LCD szeretném telepíteni rá de még csak az LCD kezelés 1 oktatóanyag jött meg.
1602 i2c lcd van és ami van a tananyagban teljesen más. Semmit se csinál ezzel a programmal.

/* LiquidCrystal
LCD fuggvenykonyvtar
2x16 karakteres LCD mintaprogram
EXT1 aramkorre hangolva

60 nap alatt Arduino tanfolyam
(c) TavIR http://www.tavir.hu */

#include "LiquidCrystal.h"
// A LiquidCrystal eljarast hasznaljuk

LiquidCrystal lcd(4, 5, 6, 7, 8, 9);
// Az LCD bekotese labak szerint:
// RS(D4), E(D5), D4(D6) ,D5(D7), D6(D8), D7(D9)

void setup() {
//Inicializalas
pinMode(13, OUTPUT);
//Az LCD hattervilagitas a D13
//Csak az EXT1 lapon!
digitalWrite(13, HIGH);
// Hatter bekapcsol
lcd.begin(16, 2);
//Az LCD 2 sor, 16 oszlopos
lcd.print("Hello, World!");
//LCD-re kiirunk szoveget
}

void loop() {
//Maga a foprogram
lcd.setCursor(0, 1);
//A kiiras helye: 0. oszlop, 1. sor
lcd.print(millis()/1000);
//eltelt masodperc a bekapcsolas ota
}
(#) antikzsolt válasza antikzsolt hozzászólására (») Nov 8, 2023 /
 
Sikerült. Rossz könyvtár volt a hiba
(#) neogeo2 válasza antikzsolt hozzászólására (») Nov 9, 2023 /
 
Ez a program nem i2c modullal ellátott lcdhez való. Akkor működik helyesen, ha nem ilyen lcd-t használsz hozzá.
(#) antikzsolt válasza neogeo2 hozzászólására (») Nov 9, 2023 / 1
 
Igen rájöttem hogy ott a hiba. Bár kellett pár óra mire rájöttem. Taviros oktatóanyagot kezdtem meg tegnap déután eddig minden is sikerült. Led villogtatás sos módban stb. Ma jött meg az lcd kezelés 2 fejezete. Azt még be kell fejeznem.
(#) antikzsolt hozzászólása Nov 11, 2023 /
 
Jó reggelt.

Mi a hiba?
Sajnos csak egész hőfokot és páratartalmat jelenít meg a küd alapján.

  1. #include <Wire.h>
  2. #include <LiquidCrystal_I2C.h>
  3. #include <DHT.h>
  4.  
  5. #define DHTPIN 2 // Kapcsold össze a DHT szenzort a digitális 2-es lábhoz
  6. #define DHTTYPE DHT11 // DHT 11 típus
  7.  
  8. LiquidCrystal_I2C lcd(0x27, 16, 2);
  9. DHT dht(DHTPIN, DHTTYPE);
  10.  
  11. unsigned long previousMillisTemp = 0; // Eltelt idő az előző hőmérés óta
  12. unsigned long previousMillisHum = 0;  // Eltelt idő az előző páratartalom mérés óta
  13. const long intervalTemp = 2000; // 2 másodperces időköz a hőméréshez
  14. const long intervalHum = 2000;  // 2 másodperces időköz a páratartalom méréshez
  15.  
  16. void setup() {
  17.   Serial.begin(9600);
  18.   lcd.init();
  19.   lcd.backlight();
  20.   lcd.setCursor(0, 0);
  21.   lcd.print("Hello, Arduino!");
  22.   lcd.setCursor(0, 1);
  23.   lcd.print("I2C LCD");
  24.   dht.begin();
  25. }
  26.  
  27. void loop() {
  28.   lcd.setCursor(0, 1);
  29.  
  30.   unsigned long currentMillis = millis();
  31.  
  32.   // Hőmérés minden 2 másodpercben
  33.   if (currentMillis - previousMillisTemp >= intervalTemp) {
  34.     previousMillisTemp = currentMillis;
  35.  
  36.     // DHT11 szenzor olvasása
  37.     float temperatureC = dht.readTemperature();
  38.  
  39.     // Ellenőrizd, hogy sikeres volt-e az olvasás
  40.     if (!isnan(temperatureC)) {
  41.       lcd.setCursor(0, 0);
  42.       lcd.print("Hommersz: ");
  43.       lcd.print(temperatureC, 1); // 1 tizedesjegyet jelenít meg
  44.       lcd.print("C");
  45.     } else {
  46.       lcd.clear();  // Kijelző törlése
  47.       lcd.setCursor(0, 0);
  48.       lcd.print("Szenzor olvasasi hiba");
  49.     }
  50.   }
  51.  
  52.   // Páratartalom mérés minden 2 másodpercben
  53.   if (currentMillis - previousMillisHum >= intervalHum) {
  54.     previousMillisHum = currentMillis;
  55.  
  56.     // DHT11 szenzor olvasása
  57.     float humidity = dht.readHumidity();
  58.  
  59.     // Ellenőrizd, hogy sikeres volt-e az olvasás
  60.     if (!isnan(humidity)) {
  61.       lcd.setCursor(0, 1);
  62.       lcd.print("Paratart: ");
  63.       lcd.print(humidity, 1); // 1 tizedesjegyet jelenít meg
  64.       lcd.print("%");
  65.     } else {
  66.       lcd.clear();  // Kijelző törlése
  67.       lcd.setCursor(0, 0);
  68.       lcd.print("Szenzor olvasasi hiba");
  69.     }
  70.   }
  71.  
  72.   delay(1000);  // Var egy másodpercet
  73. }
(#) szSzilard hozzászólása Nov 12, 2023 /
 
Sziasztok,

Arduino IDE-ben Debug-olható a Nodemcu-ra írt program?

Kösz.
(#) sargarigo válasza szSzilard hozzászólására (») Nov 13, 2023 / 1
 
Sorról sorra futtatást tudtommal egyáltalán nem támogat. Én soros portra irom a debug adatokat. Ha az túl lassú, akkor meg lehet ledet villogtatni (pl időzítésekhez) amit szkóppal nézhetsz.

szerk: az IDE2 már debuggol, noha nagyon nem mindent. Bővebben: Link
A hozzászólás módosítva: Nov 13, 2023
(#) robis01 válasza antikzsolt hozzászólására (») Nov 13, 2023 /
 
próbáld ki ezt wokwi
(#) antikzsolt válasza antikzsolt hozzászólására (») Nov 14, 2023 /
 
Jó ideje kínlódok már ezzel a kóddal.

Át tudnátok nézni nekem? Sajnos a szimulációs programok nekem nem akarnak működni. Az LCD ki lesz szedve mikor beépítésre kerül a helyére ezért szükséges a led és buzzer visszajelzés.

  1. #include <Wire.h>
  2. #include <LiquidCrystal_I2C.h>
  3. #include <DHT.h>
  4.  
  5. #define DHTPIN 2 // Kapcsold össze a DHT szenzort a digitális 2-es lábhoz
  6. #define DHTTYPE DHT11 // DHT 11 típus
  7.  
  8. #define GREEN_LED 3  // Zöld LED a 3-as digitális lábon
  9. #define YELLOW_LED 4 // Sárga LED a 4-es digitális lábon
  10. #define RED_LED 5    // Piros LED a 5-ös digitális lábon
  11.  
  12. #define BUZZER 6     // Buzzer a 6-os digitális lábon
  13.  
  14. #define RELAY 7      // Relé vezérlő tüske
  15.  
  16. LiquidCrystal_I2C lcd(0x27, 16, 2);
  17. DHT dht(DHTPIN, DHTTYPE);
  18.  
  19. unsigned long previousMillis = 0; // Eltelt idő az előző mérés óta
  20. const long interval = 60000; // 60 másodperces időköz
  21. const long buzzerDuration = 6000; // 6 másodperc
  22. const long buzzerInterval = 3000; // 3 másodperc
  23. const float hysteresis = 1.0; // Hőmérséklet hiszterézis
  24.  
  25. unsigned long buzzerTimer = 0;
  26. bool buzzerActive = false;
  27. bool relayState = false;
  28.  
  29. void setup() {
  30.   Serial.begin(9600);
  31.   lcd.init();
  32.   lcd.backlight();
  33.   lcd.setCursor(0, 0);
  34.   lcd.print("Hello, Arduino!");
  35.   lcd.setCursor(0, 1);
  36.   lcd.print("I2C LCD");
  37.  
  38.   pinMode(GREEN_LED, OUTPUT);
  39.   pinMode(YELLOW_LED, OUTPUT);
  40.   pinMode(RED_LED, OUTPUT);
  41.   pinMode(BUZZER, OUTPUT);
  42.   pinMode(RELAY, OUTPUT); // Relé vezérlő tüske
  43.  
  44.   dht.begin();
  45. }
  46.  
  47. void loop() {
  48.   unsigned long currentMillis = millis();
  49.  
  50.   // Minden percen belül egyszer végezze el a mérést és LCD frissítést
  51.   if (currentMillis - previousMillis >= interval) {
  52.     previousMillis = currentMillis;
  53.  
  54.     // Hőmérés
  55.     float temperatureC = dht.readTemperature();
  56.     if (!isnan(temperatureC)) {
  57.       lcd.setCursor(0, 0);
  58.       lcd.print("Homersek: ");
  59.       lcd.print(temperatureC, 1);
  60.       lcd.print("C");
  61.  
  62.       // Zöld LED világítása 20°C vagy magasabb hőmérséklet esetén
  63.       if (temperatureC >= 20) {
  64.         digitalWrite(GREEN_LED, HIGH);
  65.         digitalWrite(YELLOW_LED, LOW);
  66.         digitalWrite(RED_LED, LOW);
  67.         if (relayState) {
  68.           digitalWrite(RELAY, LOW); // Relé kikapcsolása
  69.           relayState = false;
  70.         }
  71.       }
  72.       // Sárga LED világítása 15-20°C között
  73.       else if (temperatureC >= 15 && temperatureC < 20) {
  74.         digitalWrite(GREEN_LED, LOW);
  75.         digitalWrite(YELLOW_LED, HIGH);
  76.         digitalWrite(RED_LED, LOW);
  77.         // Itt nem kell semmit tenni a relével
  78.       }
  79.       // Piros LED világítása 15°C alatti hőmérséklet esetén
  80.       else {
  81.         digitalWrite(GREEN_LED, LOW);
  82.         digitalWrite(YELLOW_LED, LOW);
  83.         digitalWrite(RED_LED, HIGH);
  84.  
  85.         // Buzzer riasztás, amíg 6°C alatt van a hőmérséklet
  86.         if (temperatureC < 6) {
  87.           if (!buzzerActive) {
  88.             buzzerTimer = currentMillis;
  89.             buzzerActive = true;
  90.           }
  91.  
  92.           if (currentMillis - buzzerTimer <= buzzerDuration) {
  93.             tone(BUZZER, 1000); // 1kHz frekvencia
  94.           } else if (currentMillis - buzzerTimer <= buzzerDuration + buzzerInterval) {
  95.             noTone(BUZZER); // Buzzer kikapcsolása
  96.           } else {
  97.             buzzerActive = false;
  98.           }
  99.         } else {
  100.           noTone(BUZZER); // Buzzer kikapcsolása
  101.           buzzerActive = false;
  102.         }
  103.  
  104.         // Relé vezérlése hiszterézissel
  105.         if (temperatureC < 20 - hysteresis && !relayState) {
  106.           digitalWrite(RELAY, HIGH); // Relé bekapcsolása
  107.           relayState = true;
  108.         } else if (temperatureC >= 20 && relayState) {
  109.           digitalWrite(RELAY, LOW); // Relé kikapcsolása
  110.           relayState = false;
  111.         }
  112.       }
  113.     } else
A hozzászólás módosítva: Nov 14, 2023
(#) pipi válasza antikzsolt hozzászólására (») Nov 14, 2023 / 1
 
Ha elárulnád mi a gond...
A műveleteket és biztos ami biztos bezárójelezném, hogy a műveleti sorrend úgy történjen ahogy én szeretném...
(#) Skori válasza pipi hozzászólására (») Nov 14, 2023 /
 
Pontosan. Jelen állapotában biztosra vehető, hogy gyakorlatilag az összes IF másképp viselkedik mint ami az elvárás.
A hozzászólás módosítva: Nov 14, 2023
(#) antikzsolt hozzászólása Nov 14, 2023 /
 
Még nem tudom mi lehet a hiba mert jelenleg az unot most kötöm be a feladathoz.

milyen zárójelek? Nem értem mire gondolsz.
(#) pipi válasza antikzsolt hozzászólására (») Nov 14, 2023 /
 
Ha nem tudod a hibajelenséget, akkor mit is kérdezel?
Az összes if után nézd meg mit írtál, az összetartozó műveleteket zárójelezd össze aszerint, hogy szerinted milyen sorrenben hajtódjanak végre... Akkor legalább áttekinthető
pl ezt: (temperatureC < 20 - hysteresis && !relayState)
(#) lalca válasza antikzsolt hozzászólására (») Nov 14, 2023 /
 
A dht11 csak ennyit tud, nézd meg a pdf-et.
(#) antikzsolt válasza pipi hozzászólására (») Nov 14, 2023 /
 
Be vannak zárójelezve úgy is másoltam be. Szép zöld zárójelek.
(#) Pethical válasza antikzsolt hozzászólására (») Nov 14, 2023 /
 
A programod hibátlan. A DHT11 felbontása 1°C és 8 bites páratartalom, azaz csak egész értéket tud adni neked.
(#) antikzsolt válasza Pethical hozzászólására (») Nov 14, 2023 /
 
Köszönöm. Amire akarom használni arra tökéletes lesz a dh11. Akkumulátor melegen tartásra lesz használva és riasztani fog hogyha 6 fok vagy alatta lesz. A relé meg egy 3 izzós lámpát fog kapcsolni. 12v 5w izzók. 5cm hungarocell van burkolva.
(#) antikzsolt hozzászólása Nov 14, 2023 /
 
Köszönöm mindenkinek a segítséget. Sikerült a ledeket buzert bekötni. Működik. Már csak a relét kell de már nagyon fáradt vagyok. Némi kiegészítés is került bele. Restart(nincs valós óra) és enélkül túlcsordul. Na meg egy led és buzer teszt.

  1. #include <Wire.h>
  2. #include <LiquidCrystal_I2C.h>
  3. #include <DHT.h>
  4.  
  5. #define DHTPIN 2 // Kapcsold össze a DHT szenzort a digitális 2-es lábhoz
  6. #define DHTTYPE DHT11 // DHT 11 típus
  7.  
  8. #define GREEN_LED 3  // Zöld LED a 3-as digitális lábon
  9. #define YELLOW_LED 4 // Sárga LED a 4-es digitális lábon
  10. #define RED_LED 5    // Piros LED a 5-ös digitális lábon
  11.  
  12. #define BUZZER 6     // Buzzer a 6-os digitális lábon
  13.  
  14. #define RELAY 7      // Relé vezérlő tüske
  15.  
  16. LiquidCrystal_I2C lcd(0x27, 16, 2);
  17. DHT dht(DHTPIN, DHTTYPE);
  18.  
  19. unsigned long previousMillis = 0; // Eltelt idő az előző mérés óta
  20. const long interval = 5000; // 5 másodperces időköz
  21. const long buzzerDuration = 6000; // 6 másodperc
  22. const long restartInterval = 24L * 60 * 60 * 1000; // 24 óra milliszekundumban
  23.  
  24. unsigned long buzzerTimer = 0;
  25. bool buzzerActive = false;
  26. bool relayState = false;
  27. unsigned long lastRestart = 0;
  28.  
  29. void setup() {
  30.   Serial.begin(9600);
  31.   lcd.init();
  32.   lcd.backlight();
  33.   lcd.setCursor(0, 0);
  34.   lcd.print("Hello, Arduino!");
  35.   lcd.setCursor(0, 1);
  36.   lcd.print("I2C LCD");
  37.  
  38.   pinMode(GREEN_LED, OUTPUT);
  39.   pinMode(YELLOW_LED, OUTPUT);
  40.   pinMode(RED_LED, OUTPUT);
  41.   pinMode(BUZZER, OUTPUT);
  42.   pinMode(RELAY, OUTPUT); // Relé vezérlő tüske
  43.  
  44.   dht.begin();
  45.  
  46.   // Startup függvény hívása a ledek és a buzzer bekapcsolásához
  47.   startup();
  48. }
  49.  
  50. // Függvény az Arduino újraindításához
  51. void restartArduino() {
  52.   asm volatile ("  jmp 0");
  53. }
  54.  
  55. // Függvény a ledek és a buzzer bekapcsolásához
  56. void startup() {
  57.   digitalWrite(GREEN_LED, HIGH);
  58.   digitalWrite(YELLOW_LED, HIGH);
  59.   digitalWrite(RED_LED, HIGH);
  60.  
  61.  // Szimulált alacsony hőmérséklet hangja
  62.   float simulatedTemperature = 5.0; // Szimulált hőmérséklet (6 fok alatt)
  63.   int frequency = map(simulatedTemperature, 0, 20, 500, 2000);
  64.   tone(BUZZER, frequency, buzzerDuration);
  65.   delay(buzzerDuration);
  66.   noTone(BUZZER);
  67.   digitalWrite(GREEN_LED, LOW);
  68.   digitalWrite(YELLOW_LED, LOW);
  69.   digitalWrite(RED_LED, LOW);
  70. }
  71.  
  72. void loop() {
  73.   unsigned long currentMillis = millis();
  74.  
  75.   // Az Arduino újraindítása 24 óránként egyszer
  76.   if (currentMillis - lastRestart >= restartInterval) {
  77.     restartArduino();
  78.   }
  79.  
  80.   // Minden 5 másodpercben végezze el a mérést és LCD frissítést
  81.   if (currentMillis - previousMillis >= interval) {
  82.     previousMillis = currentMillis;
  83.  
  84.     // Hőmérés
  85.     float temperatureC = dht.readTemperature();
  86.     if (!isnan(temperatureC)) {
  87.       lcd.setCursor(0, 0);
  88.       lcd.print("Homersek: ");
  89.       lcd.print(temperatureC, 1);
  90.       lcd.print("C");
  91.  
  92.       // Zöld LED világítása 20°C vagy magasabb hőmérséklet esetén
  93.       if (temperatureC >= 20) {
  94.         digitalWrite(GREEN_LED, HIGH);
  95.         digitalWrite(YELLOW_LED, LOW);
  96.         digitalWrite(RED_LED, LOW);
  97.  
  98.         // Relé kikapcsolása, ha a hőmérséklet 20°C vagy annál magasabb
  99.         if (relayState) {
  100.           digitalWrite(RELAY, LOW);
  101.           relayState = false;
  102.         }
  103.       }
  104.       // Sárga LED világítása 15-20°C között
  105.       else if (temperatureC >= 15 && temperatureC < 20) {
  106.         digitalWrite(GREEN_LED, LOW);
  107.         digitalWrite(YELLOW_LED, HIGH);
  108.         digitalWrite(RED_LED, LOW);
  109.         // Itt nem kell semmit tenni a relével
  110.       }
  111.       // Piros LED világítása 15°C alatti hőmérséklet esetén
  112.       else {
  113.         digitalWrite(GREEN_LED, LOW);
  114.         digitalWrite(YELLOW_LED, LOW);
  115.         digitalWrite(RED_LED, HIGH);
  116.  
  117.         // Buzzer szirénahang, amíg 6°C alatt van a hőmérséklet
  118.         if (temperatureC < 6) {
  119.           if (!buzzerActive) {
  120.             buzzerTimer = currentMillis;
  121.             buzzerActive = true;
  122.           }
  123.  
  124.           if (currentMillis - buzzerTimer <= buzzerDuration) {
  125.             int frequency = map(currentMillis - buzzerTimer, 0, buzzerDuration, 500, 2000);
  126.             tone(BUZZER, frequency);
  127.           } else {
  128.             buzzerActive = false;
  129.             noTone(BUZZER); // Buzzer kikapcsolása
  130.           }
  131.         } else {
  132.           noTone(BUZZER); // Buzzer kikapcsolása
  133.           buzzerActive = false;
  134.         }
  135.  
  136.         // Relé vezérlése
  137.         if (!relayState && temperatureC < 10) {
  138.           digitalWrite(RELAY, HIGH); // Relé bekapcsolása
  139.           relayState = true;
  140.         } else if (temperatureC >= 20 && relayState) {
  141.           digitalWrite(RELAY, LOW); // Relé kikapcsolása
  142.           relayState = false;
  143.         }
  144.       }
  145.     } else {
  146.       lcd.clear();
  147.       lcd.setCursor(0, 0);
  148.       lcd.print("Szenzor olvasasi hiba");
  149.     }
  150.  
  151.     // LCD törlése minden mérés után
  152.     delay(2000); // Várakozás, hogy az adatok láthatók legyenek
  153.     lcd.clear();
  154.   }
  155. }
A hozzászólás módosítva: Nov 14, 2023
(#) robis01 válasza antikzsolt hozzászólására (») Nov 15, 2023 /
 
Nem célszerű az adatlapon lévő értékeket meghaladni, mert ugyan működhet az alkatrész, de nagy valószínűséggel hibázni is fog. DHT11 adatlapja szerint
Idézet:
„Sampling period: more than 2 seconds”


A sok if helyett talán jobban áttekinthető kódot lehet készíteni a switch...case paranccsal.
(#) antikzsolt válasza robis01 hozzászólására (») Nov 15, 2023 /
 
Melyik értéket haladtam meg? Annyira nem ismerem még a programokat..így maradok ennél egy ideig.
Ezekre szükség lehet! - HESTORE.HU

ESP 2010
ATMEGA328P-AU
DHT11
ESP32-C3-DEVKITM-1
1N4007
Következő: »»   821 / 845
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