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   503 / 854
(#) kapu48 válasza Kovidivi hozzászólására (») Jan 15, 2019 /
 
Az a gond, hogy nem tudjuk, honnan kapod a 2 bytes karakter kódot?

Mert ezt esetleg meg lehetne változtatni, hogy 1 byteos kódot használjon a rendszered.
Mivel a legtöbb helyen a használt karakter kód megválasztható.
Ezért javasoltam fentebb a YAT terminált. Ez Windowsban betud neked állítani UTFT-8 készletett.
Vagy ami nálam alapbeállítás valami „Közép Európai Win(1250)” ez is csak 1Byteos ékezetes karaktereket használ, és azokat már tudnád használni akár az LCD-hez is.

Vagy ez szintén csak 1 Bytes kód tábla: ASCII table according to Windows-1252
Bővebben: Link
Használd ezt.
A hozzászólás módosítva: Jan 15, 2019
(#) tbarath válasza Kovidivi hozzászólására (») Jan 15, 2019 /
 
Szerintem az általad használt "szövegszerkesztő" használ unicode kódolást.
Javaslom tölts le egy notepad++ programot (vagy valami hasonlót), nyisd meg azzal a forrás file-t, és a format menüben próbáld meg utf-ről ansi kódolásra alakítani. (Gondolom windows-t használsz.)
(#) sargarigo válasza Kovidivi hozzászólására (») Jan 15, 2019 /
 
Esetleg egy ötlet. Én megpróbálnám azt, hogy akkor fogadjon a függvény int-et, aztán a függvényen belül meg szétszeded két részre.
  1. char fgv(int myInput)
  2. {
  3.    char highChar, lowChar;
  4.    highChar = myInput & 0bff00;
  5.    lowChar = myInput & 0b00ff;
  6.  
  7.    return lowChar;
  8. }

Arról kellene meggyőződnöd, hogy konkrétan hol jelentkezik az anomália. Valamilyen átalakításnál lesz az.
A hozzászólás módosítva: Jan 15, 2019
(#) Kovidivi válasza kapu48 hozzászólására (») Jan 15, 2019 /
 
Lehet el tudtam indulni. Pl.: char []="szoveg" az 6 byte-on lesz tárolva (az strlen szerint). Viszont a char []="szöveg" 7byte-on. Az ö betű plusz egy byte-ot foglal, és ha használom a char [2]=="ö" feltételt, nem lesz igaz. Ha " helyett '-t használok akkor se igaz. A char [1] a z, char [2] és char [3] tárolja az ö betűt. Ha átkasztolom unsigned char-ba, akkor 195 és 182 az értékük. Így már sikerülnie kell!
Azt kell még megnéznem, hogy a pgm_read_byte 1 vagy 2byte-on adja vissza az ékezetes karaktereket.
A hozzászólás módosítva: Jan 15, 2019
(#) kapu48 válasza Kovidivi hozzászólására (») Jan 15, 2019 /
 
Valahogy így képzelem el az átrendezést:
  1. // ekezetKezelo.ino
  2. #include <string.h>
  3. #include <ctype.h>
  4.  
  5. char S[128]= {"Ütve fúró gép"};
  6.  
  7. void setup() {
  8.   // put your setup code here, to run once:
  9.  
  10. }
  11.  
  12. void loop() {
  13.   // put your main code here, to run repeatedly:
  14.   int hossz = strlen (S);
  15.   int iSeged=0;
  16.   char Ss[hossz]; // A rendezett String
  17.   // Rendezzük a karakter sórt
  18.   for(int i=0; i<hossz; i++){
  19.     if(S[i]>126){ // Ha nagyobb mint ~ Equivalency sign - tilde
  20.       // Kihagyjuk és vesszük a következő Byteot
  21.       Ss[iSeged++] = S[++i]; // Akkor ide kellene a kasztolás.
  22.       // Vagy behelyettesítés a fent linkelt táblázat megfelelő kódjával
  23.     }else{
  24.       Ss[iSeged++] = S[i];
  25.      
  26.     }
  27.    
  28.   }
  29. }
A hozzászólás módosítva: Jan 15, 2019
(#) Kovidivi válasza kapu48 hozzászólására (») Jan 15, 2019 /
 
Köszi. Átnézem.
(#) kapu48 válasza kapu48 hozzászólására (») Jan 15, 2019 /
 
Írtad, hogy az strlen nem adja vissza a Stringet lezáró /0 karaktert?
Akkor változtatni kellene a for cikluson, hogy a /0-is át jöjjön.
  1. for(int i=0; i<hossz+1; i++){
  2. …
  3. }
  4. hossz=strlen(Ss); // Az új string hossza a + végén a lezáró /0
(#) sitto hozzászólása Jan 15, 2019 /
 
Sziasztok!

Programozásban kérnék egy kis segítséget. adott az alábbi kód:
  1. #include <SPI.h>
  2. #include <SD.h>
  3. #include <Wire.h>
  4. #include <TimeLib.h>
  5. #include <DS1307RTC.h>
  6.  
  7. int TMP36Pin = 0;  //the analog pin the TMP36's Vout (sense) pin is connected to the resolution is 10 mV/degree centigrade with a 500 mV offset to allow for negative temperatures
  8.  
  9. // Let's compare an average of 100
  10.   const byte averageCount = 100;
  11.  
  12. // Variables for the Modified Moving Average
  13.   double movingAverage = 0;
  14.   double movingAverageSum = 0;
  15.  
  16. // Timer variables
  17.   unsigned long previousMillis = 0;
  18.   unsigned long currentMillis = millis();
  19.   unsigned long printTempInterval = 1000;  // print out measured results every 1000 msec
  20.   unsigned long printTimeInterval = 1000;  // print out measured results every 1000 msec
  21.  
  22.   const int chip = 10;
  23.  
  24. void setup() {
  25.   // Open serial communications and wait for port to open:
  26.   Serial.begin(9600);
  27.   while (!Serial) ; // wait for serial port to connect. Needed for native USB port only
  28.  
  29.  
  30.   Serial.print("Initializing SD card...");
  31.  
  32.   // see if the card is present and can be initialized:
  33.   if (!SD.begin(chip)) {
  34.     Serial.println("Card failed, or not present");
  35.     // don't do anything more:
  36.     while (1);
  37.   }
  38.   Serial.println("card initialized.");
  39.  
  40.   // Pre-load MMA
  41.   for (int x=0; x < averageCount; x++)
  42.   movingAverageSum = movingAverageSum + analogRead(TMP36Pin);
  43.   //Serial.print(movingAverageSum);
  44.   //Serial.println(" movingAverageSum ");
  45.  
  46. // Calculate inital average
  47.   movingAverage = movingAverageSum / averageCount;
  48.   //Serial.print(movingAverage);
  49.   //Serial.println(" movingAverage ");
  50. }
  51.  
  52. void loop() {
  53.  
  54.     tmElements_t tm;
  55.    
  56.   // make a string for assembling the data to log:
  57.   String dataTemp = "";
  58.  
  59.   String dataYear = "";
  60.   String dataMonth = "";
  61.   String dataDay = "";
  62.   String dataHour = "";
  63.   String dataMinute= "";
  64.   String dataSecond = "";
  65.    
  66. //getting the voltage reading  the temperature sensor and append to the string:
  67.   int TMP36_Read = analogRead(TMP36Pin);
  68.  
  69.  
  70. //Modified Moving Avarege method used to smooth sensor data
  71.  
  72. // each interation of loop, update moving average
  73. // Get a new sample
  74. // unsigned int currentValue = analogRead(analogPin);
  75.  
  76. // Remove previous movingAverage  the sum
  77.   movingAverageSum = movingAverageSum - movingAverage;
  78.  
  79. // Replace it with the current sample
  80.   movingAverageSum = movingAverageSum + TMP36_Read;
  81.  
  82. // Recalculate movingAverage
  83.   movingAverage = movingAverageSum / averageCount;
  84.   //Serial.print(movingAverage);
  85.   //Serial.println(" calculated movingAverage ");
  86.  
  87. // analogRead values go  0 to 1023, analogWrite values  0 to 255
  88. float voltage = ((movingAverage *5000) / 1024); // Gets you mV
  89.   //Serial.print(voltage);
  90.   //Serial.println(" voltage ");
  91.  
  92. // calculate the temperature
  93.  float temperatureC = (voltage - 500) / 10 ;  //ing  10 mv per degree wit 500 mV offset to degrees ((voltage - 500mV) / 10)
  94.  
  95. // print out the time
  96.    
  97.   if (RTC.read(tm)) {
  98.     /*Serial.print(tmYearToCalendar(tm.Year));
  99.     Serial.write('-');
  100.     Serial.print(tm.Month);
  101.     Serial.write('-');
  102.     Serial.print(tm.Day);
  103.     Serial.write(',');
  104.     print2digits(tm.Hour);
  105.     Serial.write(':');
  106.     print2digits(tm.Minute);
  107.     Serial.write(':');
  108.     print2digits(tm.Second);
  109.     Serial.println();*/
  110.  
  111.   } else {
  112.     if (RTC.chipPresent()) {
  113.       Serial.println("The DS1307 is stopped.  Please run the SetTime");
  114.       Serial.println("example to initialize the time and begin running.");
  115.       Serial.println();
  116.     } else {
  117.       Serial.println("DS1307 read error!  Please check the circuitry.");
  118.       Serial.println();
  119.     }
  120.   }
  121.  
  122.  
  123.  //append to the string:
  124. dataTemp = String(temperatureC,1);
  125. dataYear = String(tmYearToCalendar(tm.Year));
  126. dataMonth = String((tm.Month));
  127. dataDay = String((tm.Day));
  128. dataHour = String((tm.Hour));
  129. dataMinute = String((tm.Minute));
  130. dataSecond = String((tm.Second));
  131.  
  132.   // open the file. note that only one file can be open at a time,
  133.   // so you have to close this one before opening another.
  134.   File dataFile = SD.open("datalog.txt", FILE_WRITE);
  135.  
  136. currentMillis = millis();
  137.  
  138. if (currentMillis-previousMillis >= printTimeInterval){
  139.    
  140.  // reset the debouncing timer
  141.     previousMillis = millis();
  142.  
  143.    
  144.   // if the file is available, write to it:
  145.   if (dataFile){
  146.     dataFile.print(dataYear);
  147.     dataFile.print("-");
  148.     dataFile.print(dataMonth);
  149.     dataFile.print("-");    
  150.     dataFile.print(dataDay);
  151.     dataFile.print("-");
  152.     dataFile.print(dataHour);
  153.     dataFile.print(":");
  154.     dataFile.print(dataMinute);
  155.     dataFile.print(":");  
  156.     dataFile.print(dataSecond);
  157.     dataFile.print(",");  
  158.     dataFile.print(dataTemp);
  159.        
  160.     dataFile.close();
  161.     // print to the serial port too:
  162.     Serial.print(dataYear);
  163.     Serial.print("-");
  164.     Serial.print(dataMonth);
  165.     Serial.print("-");    
  166.     Serial.print(dataDay);
  167.     Serial.print(",");
  168.     Serial.print(dataHour);
  169.     Serial.print(":");
  170.     Serial.print(dataMinute);
  171.     Serial.print(":");  
  172.     Serial.print(dataSecond);
  173.     Serial.print(",");  
  174.     Serial.println(dataTemp);
  175.   }
  176.   // if the file isn't open, pop up an error:
  177.   else {
  178.     Serial.println("error opening datalog.txt");
  179.   }
  180.  
  181. }
  182.  
  183. }
  184.  
  185.  
  186. void print2digits(int number) {
  187.   if (number >= 0 && number < 10) {
  188.     Serial.write('0');
  189.   }
  190.     Serial.print(number);
  191. }


A kódnak ezzel a részével van gondom:
  1. // open the file. note that only one file can be open at a time,
  2.   // so you have to close this one before opening another.
  3.   File dataFile = SD.open("datalog.txt", FILE_WRITE);
  4.  
  5. currentMillis = millis();
  6.  
  7. if (currentMillis-previousMillis >= printTimeInterval){
  8.    
  9.  // reset the debouncing timer
  10.     previousMillis = millis();
  11.  
  12.    
  13.   // if the file is available, write to it:
  14.   if (dataFile){
  15.     dataFile.print(dataYear);
  16.     dataFile.print("-");
  17.     dataFile.print(dataMonth);
  18.     dataFile.print("-");    
  19.     dataFile.print(dataDay);
  20.     dataFile.print("-");
  21.     dataFile.print(dataHour);
  22.     dataFile.print(":");
  23.     dataFile.print(dataMinute);
  24.     dataFile.print(":");  
  25.     dataFile.print(dataSecond);
  26.     dataFile.print(",");  
  27.     dataFile.print(dataTemp);
  28.        
  29.     dataFile.close();
  30.     // print to the serial port too:
  31.     Serial.print(dataYear);
  32.     Serial.print("-");
  33.     Serial.print(dataMonth);
  34.     Serial.print("-");    
  35.     Serial.print(dataDay);
  36.     Serial.print(",");
  37.     Serial.print(dataHour);
  38.     Serial.print(":");
  39.     Serial.print(dataMinute);
  40.     Serial.print(":");  
  41.     Serial.print(dataSecond);
  42.     Serial.print(",");  
  43.     Serial.println(dataTemp);
  44.   }
  45.   // if the file isn't open, pop up an error:
  46.   else {
  47.     Serial.println("error opening datalog.txt");
  48.   }
  49.  
  50. }
  51.  
  52. }


A szenzor és idő adatokat 1 másodpercenként szeretném kiiratni. A kód a az 1 másodperces időzítés nélkül működik, viszont másodpercenként kb 20 adatot ír ki, ennyire nincs szükségem.

Tehát ha a kódrészlet elején nincs benne ez a rész, akkor működik.
  1. currentMillis = millis();
  2.  
  3. if (currentMillis-previousMillis >= printTimeInterval){
  4.    
  5.  // reset the debouncing timer
  6.     previousMillis = millis();



Ha benne hagyom akkor mindig a belső if, else ágára fut és a "error opening datalog.txt" üzenetet írja ki kb 1 másodpercenként.
  1. // if the file isn't open, pop up an error:
  2.   else {
  3.     Serial.println("error opening datalog.txt");
  4.   }


Hol rontom el?
(#) szeg76 válasza sitto hozzászólására (») Jan 15, 2019 /
 
Ezt a részletet
  1. // open the file. note that only one file can be open at a time,
  2.   // so you have to close this one before opening another.
  3.   File dataFile = SD.open("datalog.txt", FILE_WRITE);


helyezd át az 1 másodpercenként lefutó részbe.
(#) sitto válasza szeg76 hozzászólására (») Jan 15, 2019 /
 
Köszönöm.
Közben találtam egy másik megoldást,
az
if (currentMillis-previousMillis >= printTimeInterval){

résznek csináltam egy else ágat és lezártam a txt fáljt
dataFile.close();

De a Te megoldásod korrektebb.

Mégegyszer köszönöm.
(#) tbarath válasza sitto hozzászólására (») Jan 15, 2019 /
 
Szeirntem a másodpercenkéni nyitós-csukós dologgal ki fogod nyírni az SD kártyát...
(#) Bakman válasza tbarath hozzászólására (») Jan 15, 2019 /
 
Ha az adatot nem felülírja hanem bővíti az adott fájlt másodprecenként, akkor adott területet csak egyszer írja az SD kártyán, nem?
(#) kissi válasza Bakman hozzászólására (») Jan 15, 2019 / 1
 
Az SD az nem FLASH alapú, azaz csak egy blokkot lehet írni egyszerre, mindegy, hogy csak 1 byte-ot akarsz !?
(#) sitto válasza tbarath hozzászólására (») Jan 15, 2019 /
 
A végleges megoldás valószínűleg egy ESP 32 lesz és a flash-t akarom használni.
Ez csak próba, hogy meg tudom-e csinálni amit akarok.
(#) tbarath válasza Bakman hozzászólására (») Jan 15, 2019 / 1
 
Van egy fizikai blokkméret, jellemzően 512 byte vagy annak többszöröse, és ha csak egy bitet is változtatsz, akkor is az egész blokkot írja újra. Aztán ott van még a logikai blokkméret, az SD kártyákon jellemzően valamilyen FAT filerendszer van, már fogalmam sincs hogy az a része milyen, utoljára DOS alatt foglalkoztam ilyesmivel, az meg rég volt.
De az biztos, hogy a FAT nem figyeli a cellák egyenletes terhelését, semmilyen wear leveling nincs benne, és a cellák kibírnak párszáz, max. párezer újraírást, aztán végük.
++ a FAT bizonyos file metadata dolgokat egy meghatározott helyen tárol a file-hoz, ha pl. minden írásnál frissíti a file dátumát, akkor az ezt tartalmazó szektor fog legelőbb megkotlani.
A hozzászólás módosítva: Jan 15, 2019
(#) Bakman válasza tbarath hozzászólására (») Jan 15, 2019 /
 
Ezért is érdemes volt felkelni ma. Különösképpen nem foglalkoztattak az SD kártyák de az infó hasznos volt.
(#) Kovidivi hozzászólása Jan 17, 2019 /
 
Sziasztok!
Progmem-es problémával fordulok hozzátok, Arduino nano alatt, de uno-n is ugyanezt produkálja.
Ha az lng változót nem használom változtatom meg a programban, akkor kioptimalizálja a fordító, és mint konstans használja, az értéke végig 0, ilyenkor jól működik a program, a tárolt szövegeket küldi át soros porton.
Viszont ha elé rakom a volatile kulcsszót az unsigned char lng=0; elé, semmi mást nem változtatok a programon, nem működik megfelelően. Ha berakok egy if (lng>10000) lng=0; , ami egyrészt sosem lesz igaz, másrészt az lng értéke alapból 0, tehát szintén nem változtatok semmit, akkor sem működik a program megfelelően, mert a fordító innentől mint változó használja, a soros monitoron szemét adatok jönnek, a memória egyik véletlen helyéről (ismétlődően). Szeretném változtatni az lng értékét a program futása alatt is. Hogyan tehetném meg? Köszi.
  1. void setup() {
  2.   Serial.begin(115200);
  3. }
  4.  
  5. const char string_0[] PROGMEM = "Merítési áram:";  
  6. const char string_1[] PROGMEM = "Belső ell.mérése";
  7. const char string_2[] PROGMEM = "merítési árammal";
  8.  
  9. const char string_0a[] PROGMEM = "1.Internal Res.";  
  10. const char string_1a[] PROGMEM = "2.Electric Load";
  11. const char string_2a[] PROGMEM = "3.Settings";
  12.  
  13. const char string_0b[] PROGMEM = "1.Innenwiderst.";  
  14. const char string_1b[] PROGMEM = "2.Elektr. Last";
  15. const char string_2b[] PROGMEM = "3.Einstellungen";
  16.  
  17. const char* const txt[3][3] PROGMEM =
  18.       {
  19.       {string_0, string_1, string_2},
  20.       {string_0a, string_1a, string_2a},
  21.       {string_0b, string_1b, string_2b}
  22.       };
  23.  
  24. //volatile unsigned char lng=0;
  25. unsigned char lng=0;
  26. void loop() {
  27.   lcd_ir(txt[lng][0]);
  28.   //if (lng>10000) lng=0;
  29.   delay(1000);
  30. }
  31.  
  32. void lcd_ir(const char *progmem_s)
  33. {
  34.   unsigned char c;
  35.   while ( (c = pgm_read_byte(progmem_s++)) )
  36.   {
  37.     Serial.print((char)c);
  38.   }
  39.   Serial.println();
  40. }
A hozzászólás módosítva: Jan 17, 2019
(#) Kovidivi válasza Kovidivi hozzászólására (») Jan 17, 2019 / 1
 
Megvan egy lehetséges megoldás, hátha valaki belefut:
Mivel egy óriási pointer tömböt használok, ezért nem muszáj a pointer tömb címét átadnom a függvénnyel, elég csak a sorszámot.
lcd_ir(txt[lng][0]); - e helyett: lcd_ir(0)-használva, átírva az lcd_ir fv-t működik a dolog.
(#) Skori hozzászólása Jan 18, 2019 /
 
Sziasztok! Arduinoval szeretnék a szokásos 2x16-os karakteres kijelzőnél valami szebb és esetleg kicsit nagyobb kijelzőt használni. Milyen kijelzőt vegyek, amit könnyű használni, és a vezérlésének nem túl nagy az erőforrásigénye?
(#) Robi válasza Skori hozzászólására (») Jan 18, 2019 /
 
Én ezt nézegettem, de még nem vettem meg. 5 IO kell neki, és van adaftuit driver hozzá (ILI9341) Sajnos tapasztalattal még nem rendelkezem vele kapcsolatban.
(#) varadi hozzászólása Jan 18, 2019 /
 
Sziasztok.
Előre bocsájtom, hogy 63 éves vagyok, 50 éve foglalkozom elektrónikával, de a most felmerűlő problémával nem tudok mit kezdeni, mert nincs semmi tapasztalatom, ezért kéne a segitség.
Nos, az egyik volt munkatársam fia, vásárolt egy Arduino alapú Smart Open 02/4WD bluetooth-os kisaútó KIT-et, azzal a tervel, hogy ő ezzel a témával áll elő a főiskolai vizsgán.
Felkértek, ha tudok segitsek.
A következő a probléma.
A kisaútó Arduino UNO memóriába feltelepitettem azt az ino kiterjesztésű programot, amit a könvtárba találtam. De viszont ez a program nem tartalmazza az ultrahangos távmérő kezelését.
Sebaj gondoltam, telepitem a könyvtárból az ultrahangos kezelő programot is,....ami sikerűlt is, de akkor meg a motorok vezérlése nem működött. Ha jól értem, akkor az Arduino egyszerre csak egy programot tud végrehajtani,....s az útalag telepitett programot csinálja, azaz lecseréli az azelőtitt.
Hogyan kéne a két programot összefűzni, egymásba másolni, úgy hogy mindkét program fússon? A segitséget előre köszönöm. Amúgy szivesen leveleznék is e témába.
(#) kissi válasza Skori hozzászólására (») Jan 18, 2019 /
 
Szia !

A kerettől függ, de szerintem Nextion vagy hasonló, soros porton kezelhető !
A szebbhez grafikus kijelző kell, de az meg erőforrás igényesebb, kivéve, ha önálló processzorral elintézi a megjelenítést csak a változásokat kell neki jelezni soros porton --> Nextion !
(#) Johnycorp válasza varadi hozzászólására (») Jan 18, 2019 /
 
Szia.

Alapvetően amit rátöltesz az eszközre programként, az is fog futni. Viszont egyszerre csak egy, ahogy te is tapasztaltad. Tehát a két programból kell készíteni újat.
A programokat össze kell fűzni. Tulajdonképpen van az Arduino programoknak egy tipikus felépítése, melybe az általad használt két program struktúrája is illeszkedik.
Szerintem töltsd fel ide a két programot (csatold az ino kiterjesztésű fájlokat mellékletként például), úgy hamarabb kapsz segítséget.

Ettől függetlenül annak a személynek kellene igencsak beleásnia magát a témába, aki ezt szeretné főiskolai vizsgán. Mert azokon a vizsgákon ez a feladat azért messze nem bonyolult és igenis önállóan el kell tudnia jutni benne egy szintig. Amikor elakad, akkor bátran kérdezhet akár itt is. Persze ettől függetlenül a segítség lehetősége most is adott, mert neked is és neki is ez egy újdonság és ilyenkor pár alapvető dologhoz adott magyarázat sokat segíthet. Továbbá ajánlom az alábbi linket:
Arduino Hivatalos Oldala (Angol)
(#) sitto hozzászólása Jan 19, 2019 /
 
Sziasztok!

Programozásban kérnék egy kis segítséget, második este küzdök vele de nem találom a hibát.
Ez a teljes kód:
  1. //Writes data to sd with correct time stemp. Measures magnetic field, temerature, TMP36, QMC5883L sensors are used. Calculates moving avarage of temperature.
  2. //Writes log data to a separate file when button pressed
  3.  
  4. #include <SPI.h>
  5. #include <SD.h>
  6. #include <SdFat.h>
  7. #include <Wire.h>
  8. #include <TimeLib.h>
  9. #include <DS1307RTC.h>
  10. #include <EEPROM.h>
  11. #include <MechaQMC5883.h>
  12.  
  13. MechaQMC5883 qmc;
  14.  
  15. int TMP36Pin = 0;  //the analog pin the TMP36's Vout (sense) pin is connected to the resolution is 10 mV/degree centigrade with a 500 mV offset to allow for negative temperatures
  16. int buttonPin = 2; //logger's press button attached to this pin
  17.  
  18. // Let's compare an average of 100
  19.   const byte averageCount = 100;
  20.  
  21. // Variables for the Modified Moving Average
  22.   double movingAverage = 0;
  23.   double movingAverageSum = 0;
  24.  
  25. // Timer variables
  26.   unsigned long previousAutoLogMillis = 0;
  27.   unsigned long currentAutoLogMillis = millis();
  28.   unsigned long printTempInterval = 1000;  // print out measured results every 1000 msec
  29.   unsigned long printTimeInterval = 1000;  // print out measured results every 1000 msec
  30.   unsigned long lastDebounceTime = 0;  // the last time the logger input button was toggled
  31.   unsigned long debounceDelay = 100;    // the debounce time; increase if the output flickers
  32.  
  33. //magnetic sensor variables
  34.   int x = 0;
  35.   int y = 0;
  36.   int z = 0;
  37.   int azimuth = 0;
  38.  
  39. //magnetic sensor array for avarage calculation, stores 10 values
  40.   const byte arraySize = 5;
  41.   double myX[arraySize];
  42.   double myY[arraySize];
  43.   double myZ[arraySize];
  44.   double myAzimuth[arraySize];
  45.   double avgX = 0;
  46.   double avgY = 0;
  47.   double avgZ = 0;
  48.   double avgAzimuth = 0;
  49.  
  50. //the current address in the EEPROM where you write the number of starts of the device
  51. int addr = 0;
  52.  
  53. //number of device starts
  54. byte starts = 0;
  55.  
  56. //chip pin for the datalogger shield, generally 4,10 or SS
  57.   const int chip = 10;
  58.  
  59. // logger button state definition
  60. int buttonState = LOW;        // the current reading  the input button
  61. int lastButtonState = LOW;   // the previous reading  the input button
  62.  
  63.  
  64. void setup() {
  65.  
  66. //define pin modes
  67.   pinMode(TMP36Pin, INPUT);
  68.   pinMode(buttonPin, INPUT);
  69.  
  70. //Join I2C bus
  71.    Wire.begin();
  72.  
  73. // Open serial communications and wait for port to open:
  74.   Serial.begin(9600);
  75.   while (!Serial) ; // wait for serial port to connect. Needed for native USB port only
  76.  
  77. //QMC 5853 magnetic sensor initialization
  78.     qmc.init();
  79.   //qmc.setMode(Mode_Continuous,ODR_200Hz,RNG_2G,OSR_256);
  80.  
  81. // read a byte  the current address of the EEPROM
  82.   starts = EEPROM.read(addr);
  83.   starts = starts +1;
  84.   EEPROM.write(addr, starts);
  85.  
  86. //Sd card initialization
  87.   Serial.println("Initializing SD card...");
  88.  
  89.   // see if the card is present and can be initialized:
  90.   if (!SD.begin(chip)) {
  91.     Serial.println("Card failed, or not present");
  92.     // don't do anything more:
  93.     while (1);
  94.   }
  95.   Serial.println("Card initialized.");
  96.  
  97.  //Log file name generation
  98.  //Serial.println (("Log file: Log_") + String(starts) + (".csv") + (" is created"));
  99.  
  100.  
  101.   // Pre-load MMA
  102.   for (int x=0; x < averageCount; x++)
  103.   movingAverageSum = movingAverageSum + analogRead(TMP36Pin);
  104.   //Serial.print(movingAverageSum);
  105.   //Serial.println(" movingAverageSum ");
  106.  
  107. // Calculate inital average
  108.   movingAverage = movingAverageSum / averageCount;
  109.   //Serial.print(movingAverage);
  110.   //Serial.println(" movingAverage ");
  111.   Serial.println("MMA preloaded");
  112.  
  113.   Serial.println ("Date,Time,Temperature,X,Y,Z,Azimuth");
  114. }
  115.  
  116. void loop() {
  117.  
  118.     tmElements_t tm;
  119.    
  120.   // make a string for assembling the data to log:
  121.   String dataTemp = "";
  122.  
  123.   String dataYear = "";
  124.   String dataMonth = "";
  125.   String dataDay = "";
  126.   String dataHour = "";
  127.   String dataMinute= "";
  128.   String dataSecond = "";
  129.  
  130.   String dataX = "";
  131.   String dataY = "";
  132.   String dataZ = "";
  133.   String dataAzimuth = "";
  134.    
  135. //getting the voltage reading  the temperature sensor and append to the string:
  136.   int TMP36_Read = analogRead(TMP36Pin);
  137.  
  138. // read the state of the log er button into a local variable:
  139.   int reading = digitalRead(buttonPin);
  140.  
  141. // If the switch changed, due to noise or pressing:
  142.   if (reading != lastButtonState) {
  143.     // reset the debouncing timer
  144.     lastDebounceTime = millis();
  145.   }
  146.  
  147.  
  148. //Modified Moving Avarege method used to smooth sensor data
  149.  
  150. // each interation of loop, update moving average
  151. // Get a new sample
  152. // unsigned int currentValue = analogRead(analogPin);
  153.  
  154. // Remove previous movingAverage  the sum
  155.   movingAverageSum = movingAverageSum - movingAverage;
  156.  
  157. // Replace it with the current sample
  158.   movingAverageSum = movingAverageSum + TMP36_Read;
  159.  
  160. // Recalculate movingAverage
  161.   movingAverage = movingAverageSum / averageCount;
  162.   //Serial.print(movingAverage);
  163.   //Serial.println(" calculated movingAverage ");
  164.  
  165. // analogRead values go  0 to 1023, analogWrite values  0 to 255
  166. float voltage = ((movingAverage *5000) / 1024); // Gets you mV
  167.   //Serial.print(voltage);
  168.   //Serial.println(" voltage ");
  169.  
  170. // calculate the temperature
  171.  float temperatureC = (voltage - 500) / 10 ;  //ing  10 mv per degree wit 500 mV offset to degrees ((voltage - 500mV) / 10)
  172.  
  173.  
  174. //azimuth calculation  //is supporting float too
  175.   qmc.read(&x, &y, &z,&azimuth);  //azimuth = qmc.azimuth(&y,&x);//you can get custom azimuth
  176.  
  177. // print out the time
  178.    
  179.   if (RTC.read(tm)) {
  180.     /*Serial.print(tmYearToCalendar(tm.Year));
  181.     Serial.write('-');
  182.     Serial.print(tm.Month);
  183.     Serial.write('-');
  184.     Serial.print(tm.Day);
  185.     Serial.write(',');
  186.     print2digits(tm.Hour);
  187.     Serial.write(':');
  188.     print2digits(tm.Minute);
  189.     Serial.write(':');
  190.     print2digits(tm.Second);
  191.     Serial.println();*/
  192.  
  193.   } else {
  194.     if (RTC.chipPresent()) {
  195.       Serial.println("The DS1307 is stopped.  Please run the SetTime");
  196.       Serial.println("example to initialize the time and begin running.");
  197.       Serial.println();
  198.     } else {
  199.       Serial.println("DS1307 read error!  Please check the circuitry.");
  200.       Serial.println();
  201.     }
  202.   }
  203.  
  204.  
  205. //append temperature data to the string:
  206. dataTemp = String(temperatureC,1);
  207.  
  208. //append date and time data to the string:
  209. dataYear = String(tmYearToCalendar(tm.Year));
  210. dataMonth = String((tm.Month));
  211. dataDay = String((tm.Day));
  212. dataHour = String((tm.Hour));
  213. dataMinute = String((tm.Minute));
  214. dataSecond = String((tm.Second));
  215.  
  216. //append compass data to the string:
  217. dataX = String(x);
  218. dataY = String(y);
  219. dataZ = String(z);
  220. dataAzimuth = String(azimuth);
  221.  
  222.   // open the file. note that only one file can be open at a time,
  223.   // so you have to close this one before opening another.
  224.  
  225.     SdFile::dateTimeCallback(dateTime);
  226.  
  227.  
  228.     currentAutoLogMillis = millis();
  229.  
  230. if (currentAutoLogMillis-previousAutoLogMillis >= printTimeInterval){
  231.      // reset the timer
  232.     previousAutoLogMillis = millis();
  233.  
  234.     //open the log file for writing
  235.     File dataFile = SD.open("Log_" + String(starts) + ".csv", FILE_WRITE);
  236.  
  237.        
  238.   // if the file is opened write data into it:
  239.   if (dataFile){
  240.      
  241.     dataFile.print(dataYear);
  242.     dataFile.print(".");
  243.     dataFile.print(dataMonth);
  244.     dataFile.print(".");    
  245.     dataFile.print(dataDay);
  246.     dataFile.print(",");
  247.     dataFile.print(dataHour);
  248.     dataFile.print(":");
  249.     dataFile.print(dataMinute);
  250.     dataFile.print(":");  
  251.     dataFile.print(dataSecond);
  252.     dataFile.print(",");  
  253.     dataFile.print(dataTemp);
  254.     dataFile.print(",");  
  255.     dataFile.print(dataX);
  256.     dataFile.print(",");  
  257.     dataFile.print(dataY);
  258.     dataFile.print(",");  
  259.     dataFile.print(dataZ);
  260.     dataFile.print(",");  
  261.     dataFile.println(dataAzimuth);    
  262.  
  263. // close log file
  264.     dataFile.close();
  265.    
  266. // print to the serial port too:
  267.     Serial.print(dataYear);
  268.     Serial.print(".");
  269.     Serial.print(dataMonth);
  270.     Serial.print(".");    
  271.     Serial.print(dataDay);
  272.     Serial.print(",");
  273.     Serial.print(dataHour);
  274.     Serial.print(":");
  275.     Serial.print(dataMinute);
  276.     Serial.print(":");  
  277.     Serial.print(dataSecond);
  278.     Serial.print(",");  
  279.     Serial.print(dataTemp);
  280.     Serial.print(",");  
  281.     Serial.print(dataX);
  282.     Serial.print(",");  
  283.     Serial.print(dataY);
  284.     Serial.print(",");  
  285.     Serial.print(dataZ);
  286.     Serial.print(",");  
  287.     Serial.println(dataAzimuth);
  288.   }
  289.  
  290.   // if the file isn't open, pop up an error:
  291.   else {
  292.     Serial.println("error opening General log file");
  293.   }
  294. }
  295.  
  296.  
  297. // whatever the reading is at, it's been there for longer than the debounce delay, so take it as the actual current state:
  298.  if (millis() - lastDebounceTime > debounceDelay) {
  299.  
  300.   // if the button state has changed:
  301.     if (reading != buttonState) {
  302.       buttonState = reading;
  303.            
  304.     // only toggle the LED if the new button state is HIGH
  305.       if (buttonState == HIGH) {
  306.  
  307.  
  308.  //**************************
  309.  
  310.     Serial.println("Custom log data: ");
  311.    
  312.  for (int i=0; i <= arraySize-1; i++){
  313.             myX[i] = x;
  314.             Serial.print(myX[i]);
  315.             Serial.print(" ");
  316.       }
  317.         Serial.println();
  318.        
  319.       for (int i=0; i <= arraySize-1; i++){
  320.             myY[i] = y;
  321.             Serial.print(myY[i]);
  322.             Serial.print(" ");
  323.       }
  324.         Serial.println();
  325.  
  326.       for (int i=0; i <= arraySize-1; i++){
  327.             myZ[i] = z;
  328.             Serial.print(myZ[i]);
  329.             Serial.print(" ");
  330.       }
  331.         Serial.println();
  332.  
  333.       for (int i=0; i <= arraySize-1; i++){
  334.             myAzimuth[i] = azimuth;
  335.             Serial.print(myAzimuth[i]);
  336.             Serial.print(" ");
  337.       }
  338.      
  339.         Serial.println();
  340.  
  341.        
  342.         avgX = 0;
  343.         avgY = 0;
  344.         avgZ = 0;
  345.         avgAzimuth = 0;
  346.         for (int i=0; i <= arraySize-1; i++){
  347.             //avgX = avgX + myX[i];
  348.             //avgY = avgY + myY[i];
  349.             avgZ = avgZ + myZ[i];
  350.             avgAzimuth = avgAzimuth + myAzimuth[i];
  351.       }
  352.  
  353.         Serial.println("Avarage values: ");
  354.         avgX = avgX/arraySize;
  355.         avgY = avgY/arraySize;
  356.         avgZ = avgZ/arraySize;
  357.         avgAzimuth = avgAzimuth/arraySize;
  358.        
  359.         //Serial.print("Avarage X value: ");
  360.         Serial.println(avgX);
  361.         //Serial.print("Avarage Y value: ");
  362.         Serial.println(avgY);
  363.         //Serial.print("Avarage Z value: ");
  364.         Serial.println(avgZ);
  365.         //Serial.print("Avarage Azimuth value: ");
  366.         Serial.println(avgAzimuth);
  367.  
  368.  //*************************
  369.        
  370.     //open the log file for writing
  371.         File customFile = SD.open("Dlog_" + String(starts) + ".csv", FILE_WRITE);
  372.        
  373.      // if the file is opened write data into it:    
  374.         if (customFile){
  375.                  
  376.         customFile.print(dataYear);
  377.         customFile.print(".");
  378.         customFile.print(dataMonth);
  379.         customFile.print(".");    
  380.         customFile.print(dataDay);
  381.         customFile.print(",");
  382.         customFile.print(dataHour);
  383.         customFile.print(":");
  384.         customFile.print(dataMinute);
  385.         customFile.print(":");  
  386.         customFile.print(dataSecond);
  387.         customFile.print(",");  
  388.         customFile.print(dataTemp);
  389.         customFile.print(",");  
  390.         customFile.print(dataX);
  391.         customFile.print(",");  
  392.         customFile.print(dataY);
  393.         customFile.print(",");  
  394.         customFile.print(dataZ);
  395.         customFile.print(",");  
  396.         customFile.println(dataAzimuth);
  397.        
  398.  // close log file  
  399.         customFile.close();
  400.         Serial.println("Custom log written");
  401.       }
  402.     }
  403.   }
  404.  }
  405.  
  406. // save the reading. Next time through the loop, it'll be the lastButtonState
  407.  lastButtonState = reading;  
  408.  
  409.  
  410.  
  411. }
  412.  
  413. /* Additional functions */
  414. /**************************************/
  415.  
  416. void print2digits(int number) {
  417.   if (number >= 0 && number < 10) {
  418.     Serial.write('0');
  419.   }
  420.     Serial.print(number);
  421. }
  422.  
  423.  
  424.  
  425. void dateTime(uint16_t* date, uint16_t* time) {
  426.     tmElements_t tm;
  427.     RTC.read(tm);
  428.   // return date using FAT_DATE macro to format fields
  429.   *date = FAT_DATE(tmYearToCalendar(tm.Year), tm.Month, tm.Day);
  430.  
  431.   // return time using FAT_TIME macro to format fields
  432.   *time = FAT_TIME(tm.Hour, tm.Minute, tm.Second);
  433. }



A kódnak ezzel a részével van a gondom:
  1. avgX = 0;
  2.         avgY = 0;
  3.         avgZ = 0;
  4.         avgAzimuth = 0;
  5.         for (int i=0; i <= arraySize-1; i++){
  6.             //avgX = avgX + myX[i];
  7.             //avgY = avgY + myY[i];
  8.             avgZ = avgZ + myZ[i];
  9.             avgAzimuth = avgAzimuth + myAzimuth[i];
  10.       }
  11.  
  12.         Serial.println("Avarage values: ");
  13.         avgX = avgX/arraySize;
  14.         avgY = avgY/arraySize;
  15.         avgZ = avgZ/arraySize;
  16.         avgAzimuth = avgAzimuth/arraySize;
  17.        
  18.         //Serial.print("Avarage X value: ");
  19.         Serial.println(avgX);
  20.         //Serial.print("Avarage Y value: ");
  21.         Serial.println(avgY);
  22.         //Serial.print("Avarage Z value: ");
  23.         Serial.println(avgZ);
  24.         //Serial.print("Avarage Azimuth value: ");
  25.         Serial.println(avgAzimuth);


Jelenleg azt csinálom, hogy egy tömbbe neolvasok 5 adatot, majd annak kiszámolom az átlagát és kiiratom a soros porta.
Eddig működik is a dolog:

  1. Initializing SD card...
  2. Card initialized.
  3. Date,Time,Temperature,X,Y,Z,Azimuth
  4. 2019.1.18,23:17:2,27.6,788,-1102,-372,305
  5. 2019.1.18,23:17:3,26.3,798,-1103,-362,305
  6. 2019.1.18,23:17:4,26.3,788,-1095,-357,305
  7. 2019.1.18,23:17:5,26.2,801,-1102,-367,306
  8. 2019.1.18,23:17:6,27.0,783,-1102,-365,305
  9. 2019.1.18,23:17:7,26.9,753,-1113,-365,304
  10. 2019.1.18,23:17:8,26.8,768,-1106,-355,304
  11. Custom log data:
  12. 791.00 791.00 791.00 791.00 791.00
  13. -1118.00 -1118.00 -1118.00 -1118.00 -1118.00
  14. -372.00 -372.00 -372.00 -372.00 -372.00
  15. 305.00 305.00 305.00 305.00 305.00
  16. Avarage values:
  17. 0.00
  18. 0.00
  19. -372.00
  20. 305.00
  21. Custom log written
  22. 2019.1.18,23:17:9,26.9,778,-1113,-367,304
  23. 2019.1.18,23:17:10,26.5,763,-1111,-370,304
  24. 2019.1.18,23:17:11,26.5,773,-1111,-377,304
  25. 2019.1.18,23:17:12,26.5,783,-1123,-355,304
  26. 2019.1.18,23:17:13,26.5,766,-1116,-372,304



Az összegzést és így az átlagszámítást viszonz csak 2 változóra tudom elvégezni:
Ha az alábbi 2 kódrészletben bármelyik rész kikommentelését megszűntetem akkor az "error opening General log file" hibaüzenetet kapom. Nem értem, hogy ennek mi köze van ehhez a kódrészlethez.
Azt tapasztaltam, hogy 2 illetve 4 sort az összegzésnél és a kiiratásnál is ki kell kommentelni. Mindegy, hogy melyikeket.
Ha a tömböm méretét (arraySize) megnövelem 5-ről 10-re, az is ugyan ezt a jelenséget okozza.
Ha lecsökkentem 3-ra, akkor egy sort visszarakhatok. Vagy összegzést vagy soros porta kiiratást. De csak 1-et.

  1. for (int i=0; i <= arraySize-1; i++){
  2.             //avgX = avgX + myX[i];
  3.             //avgY = avgY + myY[i];
  4.             avgZ = avgZ + myZ[i];
  5.             avgAzimuth = avgAzimuth + myAzimuth[i];


  1. //Serial.print("Avarage X value: ");
  2.         Serial.println(avgX);
  3.         //Serial.print("Avarage Y value: ");
  4.         Serial.println(avgY);
  5.         //Serial.print("Avarage Z value: ");
  6.         Serial.println(avgZ);
  7.         //Serial.print("Avarage Azimuth value: ");
  8.         Serial.println(avgAzimuth)



Van v.kinek v.mi ötlete?
A hozzászólás módosítva: Jan 19, 2019
(#) kapu48 válasza sitto hozzászólására (») Jan 19, 2019 /
 
Nagyon valószínű, hogy elfogyott a memória!
Próbáld meg a Flash kapcsolót használni az ilyen kiíratásoknál:
  1. Serial.println("The DS1307 is stopped.  Please run the SetTime");

Tehát ahol constans szöveget használsz, azt mindenűt kiegészíted így:
  1. Serial.println(F("The DS1307 is stopped.  Please run the SetTime"));

Ezzel eléred, hogy nem másolja be a stringeket az alkalmazás a Ramba, hanem közvetlenül a flashból írja ki.
Nagyon sok memóriát megspórolhatsz így.

Bővebben: Link
A hozzászólás módosítva: Jan 19, 2019
(#) Kera_Will válasza varadi hozzászólására (») Jan 19, 2019 /
 
Kövessétek az előző lapon lévő irodalmak hivatkozásait:

itt lévőt
(#) sitto válasza kapu48 hozzászólására (») Jan 19, 2019 /
 
Köszönöm!!

Ez megoldotta a hibát.
Viszont újabb kérdést generált.

A hibásan működő kód betöltése után ez az eredmény:

Sketch uses 22038 bytes (71%) of program storage space. Maximum is 30720 bytes.
Global variables use 1553 bytes (75%) of dynamic memory, leaving 495 bytes for local variables. Maximum is 2048 bytes.
Low memory available, stability problems may occur.

Ugyan az a kód csak a Flash kapcsolót használva pedig ez:

Sketch uses 22314 bytes (72%) of program storage space. Maximum is 30720 bytes.
Global variables use 1299 bytes (63%) of dynamic memory, leaving 749 bytes for local variables. Maximum is 2048 bytes.

Látható, hogy a kód így több helyet foglal, viszont a dinamikus memória foglalás 12%-al csökkent.

Sajnos kb. csak a kód megírásának a felénél tartok és a jelek szerint nem lesz elég memória.
Még 1 szenzor, lcd és a szenzor adatok kiértékelése hátra van.
Van e v.mi általános szabály arra nézve, hogy meddig lehet felmenni azzel a két % értékkel?
Illetve, hogyan tudnám tovább csökkenteni a kódot (a változók típusát még átnézem)?
A hozzászólás módosítva: Jan 19, 2019
(#) szeg76 válasza sitto hozzászólására (») Jan 19, 2019 /
 
Biztosan kell az összes String típusú dataxyz nevű változó?
Mi lenne, ha a numerikus értékeket ezek nélkül az egyetlen célra létrehozott tárolók nélkül készítenéd elő kiíratásra?
Pl:
  1. int ev=2019;
  2.  byte ho=12, nap=31;
  3.  float atlag=123.456, csucs=333.333;
  4.  String strKimenet;
  5.  Serial.begin(9600);
  6.  strKimenet=String("Dátum:");
  7.  strKimenet+=ev+String(".")+ho+"."+nap+"., Átlag:"+atlag+" Csúcs:"+csucs;
  8.  Serial.println( strKimenet );
(#) kapu48 válasza sitto hozzászólására (») Jan 19, 2019 /
 
Például ne foglalj le memóriát ismeretlen mérettel óriási pazarlás: String dataYear = ""; ???
(Lefoglalja a max méretet 255 Byte?)
Az év az max 4+\0 char ez kerekítve páros számra=6 char tehát: String dataYear[6] = "";
Ez csak 6 Byte foglalás.
Másik ne foglalj feleslegesen int-et (2 Byte) ahol az 1 Byte is elég.

Más szerintem ez így SD gyilkos alkalmazás lesz! Nem kellene mindig írni a kártyára.
Mert az mindig 1 blokk újraírását jelenti, tehát összekellene gyűjteni 1 blokknyi adatott és egyszerre kiírni.
Pl. van az RTC-ben is 56 Byte nem felejtő RAM, felhasználható lenne ideiglenes tárolásra.
(#) tbarath válasza szeg76 hozzászólására (») Jan 19, 2019 /
 
Illetve javasolt a String osztály mellőzése, az eléggé bloat. Ha szükséges, akkor lehet helyette megfelelő méretű char tömböt használni. De ennél a példánál pl. nem is szükséges:
  1. int ev=2019;
  2. byte ho=12, nap=31;
  3. float atlag=123.456, csucs=333.333;
  4. Serial.begin(9600);
  5. Serial.print("Dátum:");
  6. Serial.print(ev);
  7. Serial.print('.');
  8. Serial.print(ho);
  9. Serial.print('.');
  10. Serial.print(nap);
  11. Serial.print("., Átlag:");
  12. Serial.print(atlag);
  13. Serial.print(" Csúcs:");
  14. Serial.println(csucs);
Ezekre szükség lehet! - HESTORE.HU

DS1307
TMP36GT9Z
RY611012
NCR18650B-WOP
4 MHz
Következő: »»   503 / 854
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