vastloper op serial.print

Arduino specifieke Software
Berichten: 50
Geregistreerd: 09 Jun 2020, 22:11
Woonplaats: Roosendaal

vastloper op serial.print

Berichtdoor Frans53! » 11 Nov 2020, 15:12

Dagdag,
Ik loop tegen een heel vreemd probleem aan.
Ik heb een NANO 33 BLE, die vastloopt op een Serial.print-regel.

Serial.println(F("<< Regel 397 Tabel na ontvangst serieel voor aanmaak overzichtbestand."));

Met of zonder F maakt niet uit.
Opnieuw intikken ookt niet. Oorspronkelijk stond er nog een tab \t in.
Hier begrijp ik iets helemaal niet.

Wie wel?
Groetjes,
Frans.

Advertisement

Berichten: 50
Geregistreerd: 09 Jun 2020, 22:11
Woonplaats: Roosendaal

Re: vastloper op serial.print

Berichtdoor Frans53! » 11 Nov 2020, 15:19

hier ben ik zelf weer.

Als ik de tekst in tweeen hak, gaat het wél goed.

Is het misschien zo, dat een printregel aan een bepaald maximum lengte gebonden is??

Groet,
Frans.

Gebruikers-avatar
Berichten: 2655
Geregistreerd: 06 Aug 2016, 01:03

Re: vastloper op serial.print

Berichtdoor Koepel » 11 Nov 2020, 17:56

Dat zou een bug kunnen zijn.
De standaard buffer (in software) is 64 bytes. Jouw tekst is iets langer.

Ik weet niet of de buffer voor de Nano 33 BLE ook 64 byte heeft.
Nano 33 BLE: https://store.arduino.cc/arduino-nano-33-ble.
Die heeft een nRF52840 processor (32-bit ARM® Cortex™-M4 CPU running at 64 MHz). Die wordt maar weinig gebruikt.
Vrijwel iedere keer als Arduino een uitstapje maakt naar een vreemde processor, dan wordt het een drama.

De ATmega328P in de Arduino Uno wordt het meest gebruikt, en het heeft vele jaren geduurd voordat alle irritante bugs er uit waren. Pas dit jaar kwam het in orde met Arduino IDE 1.8.13 (dat is dus de allernieuwste versie). Dus pas sinds 5 maanden is de Arduino Uno op een betrouwbare manier te gebruiken, maar daarvoor moet je wel een ongedocumenteerde functie aanroepen voor de I2C bus :o
Het is dus goed mogelijk dan die Nano 33 BLE nog allerlei bugs heeft.

Voor Bluetooth kun je ook een ESP32 nemen.

Kun je de sketch laten zien ?

Berichten: 50
Geregistreerd: 09 Jun 2020, 22:11
Woonplaats: Roosendaal

Re: vastloper op serial.print

Berichtdoor Frans53! » 11 Nov 2020, 22:31

Nou, daar gaan we weer, derde poging.
De eerste was niet opgeslagen in mijn lijst met concepten,
De tweede kwam ik ineens in HTML terecht door een klikje op... op wat?? En die kreeg ik niet meer terug, dus afsluiten was de enige optie.
Nou ja....

Bedankt voor je reactie.

Het was inderdaad een buffer overloop, Deze NANO kan daar niet tegen, waardoor hij vast liep.
Die lange zin was overigens alleen een informatieteks om de voortgang van het programma te kunnen monitoren.

De reden dat ik de NANO BLE gebruik zijn de indrukwekkende eigenschappen, bij het kleine formaat.
Ik heb namelijk een SD station eraan gekoppeld, en de BLE kan daar heel goed mee overweg. Eerder had ik daarvoor zelfs twee stuks normale NANO in gebruik, maar dat werd een drama.
De blue tooth gebruik ik niet.
De perikelen waar jij het over hebt heb ik nauwelijks. Sinds de update van het IDE heb ik nog geen klachten. Dat het poortgebruik zijn eigenwize handleidig heeft, neem ik graag op de koop toe, maar ook dat is verbeterd, maar verder OK.

Ik ben bezig een uitgebreid weerstation te bouwen. Alle data wil ik opslaan om later in excel uit te werken in statistieken. Ik geef mezelf daar een paar jaar voor, maar heb een zee van tijd, omdat ik gepensioeneerd ben. haha.
Elk onderdeel van het weerstataion, de bedienigen en het SD station hebben allemaal hun eigen adruino NANO (normale), of een MEGA 2560. Alles aan elkaar gehangen met RS485 met eigen protocol.

Je vraagt om het programma. Ik heb nog niet gevonden hoe ik die moet versturen. Want als bijlage accepteerd die het niet (.ino) En ik zie nergens een "knop" om een sketch te uploaden. Vertel me maar hoe ik het wel kan doen.

Groetjes,
Frans

Gebruikers-avatar
Berichten: 2655
Geregistreerd: 06 Aug 2016, 01:03

Re: vastloper op serial.print

Berichtdoor Koepel » 12 Nov 2020, 01:08

Als je op "Plaats een reactie" klikt dan krijg je knoppen boven het tekstveld.
De knop "Code" geeft de code-tags. Zet je sketch daar tussen. Dus je sketch selecteren en kopiëren vanuit de Arduino IDE en dan plakken tussen de code-tags in je bericht op dit forum.

Vanuit de Arduino IDE kun je ook die code-tags om je sketch heen zetten.
menu: Bewerken / Kopiëren voor het forum.
Dan staat het inclusief code-tags in het clipboard.
Daarna plakken in het bericht op dit forum.

De code-tags zijn [ code ] en [ / code ] maar dan zonder spaties.

Code: Alles selecteren
Hallo, dit is tussen code tags.


cpp code
Hallo, dit is het alternatief via "Select a Syntax" en dan "C++"

Berichten: 50
Geregistreerd: 09 Jun 2020, 22:11
Woonplaats: Roosendaal

Re: vastloper op serial.print

Berichtdoor Frans53! » 12 Nov 2020, 15:06

De vastloper is allang opgelost.
Het versturen van de sketch is iets meer dan alleen maar die te lange regel.
Maar je krijgt 'm, het is geen geheim. Maar misschien moet het onder een ander onderwerp???

Groetjes,
Frans.
Code: Alles selecteren
/*
 * project 80 SD BLE
 *
 * auteur Frans Goeman
 * 29-5-2020
 * 4-6-2020 met RS485 uitgewerkt
 * ?-6-2020 met data opslag uitgewerkt
 * 16-6-2020 Uitgangsproject 80-4, wordt nu dus 80-1 BLE.
 * 18-6-2020 versie 2: software serial werkt niet, moet serial1 worden op pennen 0 en 1.
 * 26-6-2020 elke dag nieuwe datum-map werkt goed. OK.
 *    Nu nog automatisch datum-bestand.
 *    Verder initbestand aanvullen met weerhuisje.
 *    weerhuisje invoeren, gaat nu nog niet goed.
 * 29-6-2020 versie 6, vervolg van versie 4. SD geformateerd, want liep steeds vast op schrijfpogigen.
 * 15-7-2020 versie 6 enigszinds aangepast, zodat nieuwe SD kaart werkt.
 * 16-7-2020 versie 6. data van weerhuisje is goed verwerkt.
 *    Alleen met het heen en weer schakelen met monitor, precies op het hele uur,
 *    is het backupdeel niet goed gegaan, onderbroken.
 * 20-7-2020 versie 6: invoer data van weerhuisje is nu goed, inclusief controlegetal.
 * 21-7-2020 versie 7: toon data weerhuisje op scherm vanuit SD.
 * 1-8-2020 om 00:00 uur niet testen op 00:00, maar op minuut <4,
 *    zodat er altijd een nieuwe datum-map wordt gemaakt. Als die nú mis loopt,
 *    wordt die niet aangemaakt, met als gevolg dat data
 *    op de verkeerde dag worden opgeslagen.
 * 1-8-2020 verder met toon data weerhuisje. Nu in DUMP.
 * 4-8-2020 data weerhuisje nu OK, ook met uitlezen.
 * 6-8-2020 Tóch nog geen datumbestand aangemaakt. Gaat wél verder met opslaan op vorige datum.
 *    Voorwaarde voor aanmaak nieuwe dag opgehoogd van 4 naar 14 minuten.
 *    tevens nieuwe versie 8.
 * 9-8-2020 data uitlezen gaat nu goed. Maar 2 bestanden openen maakt heel erg traag.
 *    Beter bestand voor bestand uitlezen.
 *    Ook monitor pas weer vrijgeven bij 2e keer drukken op de knop. of op time-out.
 * 28-10-2020 Versie 9. regenmeter voor opslag. Met tijdseenheid van minutenperdag.   
 *    Maar ook nieuwe opzet serial, zodat er niets wordt gemist. OK.
 *    DOEN: aanmaak nieuwe datummap om middernacht met als dag > vorige dag. OK.
 *    Gemaakt: Verwijderen bestanden en mappen, nu nog op zijn janboerenfluitjes, waarbij álle
 *        bestanden loorlopen moeten worden. (héél erg veel). Maar het werkt wel.
 *        Vergeet hierbij niet dat eerst de bestanden uit de mappen verwijdert dienen te worden,
 *        alvorens de map zelf wordt verwijderd.
 *    Wat ook belangrijk is, de verandering van opslaan van de data in de tijd. Oorspronkelijk
 *        werd er een intervaltijdseenheid gebruikt dat data werd verstuurd. Ik heb me er nog
 *        niet aan gewaagd om hiermee aan de slag te gaan; alleen bij verwerking van de data
 *        zou dit belangrijk zijn geweest. Nu is bij elke waarneming een tijdsitem mee opgeslagen.
 *        Ook het vasthouden van data, totdat er genoeg is verzameld voor verzending, is weggevallen.
 *        Nu zijn de data verstuurd naar het display tevens bedoeld voor de SD. Omdat de term
 *        stationBestemming is komen te vervallen is alle data voor iedereen beschikbaar, en
 *        kan ieder station zelf bepalen of die er iets mee doet of niet.
 * Versie 10 5-11-2020.       
 *    aanpassen bestanden met tijd in aantal minuten van de dag.
 *        Hierdoor ook pas na middernacht als alle data binnen is, dan pas nieuwe datummap aanmaken.
 * versie 12. Tabellen voor statistieken laten beginnen met [1] ipv. [0]. Het wemelt anders overal van de +1 en -1.       
 *
 * versie 13, 11-11-2020 KOMMA gescheiden opslag.
 *    Hierbij worden ook dezelfde aanroepen van functies aangehouden.
 *    Het enige verschil is de aanroep van de variabele.
 *    Dit is volgens mij ook wat er veel in biblioteken gebeurd.
 *
 */
 
  // +++++++++++ init sd
  #include <SPI.h>
  #include <SD.h>

  Sd2Card card;
  SdVolume volume;
  //SdFile root;
  //File myFile1;
  //File myFile2;
  const byte chipSelect = 4;
  // CS op 4
  // SCK op 13
  // MOSI op 11
  // MISO op 12

  // +++++++++++++++ init serieel
   
    const byte stationIk = 80;
   
    const byte ssRW = 10;
    const byte ssZenden = HIGH;
    const byte ssOntvangen = LOW;
    const byte stZenden = 9;
    const byte stOk = 99;
    const byte stFout = 100;
   
   
  // ss algemeen +++++++++++++     
   
    const byte alleStations = 0;
    int stationBestemming = 0;
    int stationZender;
    byte opdracht;
    byte subopdracht;
    byte oorsprOpdracht;
    byte berichtStatus;
    byte zendopdracht = 0;
   
// ss data bytes ontvangen
       
    byte data[65];
    byte telData;
    byte verwerkTelData;
    byte ontvangControlegetal;
    byte ontvangVergelijkControlegetal;
    byte _ontvangVergelijkControlegetal;

// ss data bytes verzenden

    byte zendData[64];
    byte vulZendpnt = 0;
    byte verzendpnt = 0;
    byte zendControlegetal;
      // ponters staan altijd op de volgende cel.

    byte zendDataSD[64];
    byte dataPntSD = 0;
    byte zendSDcontrolegetal;

    int sensor1;
    boolean dataMonitor = false;
       
  // ++++++++++ klok
    byte jaar;
    byte maand;
    byte dagnr;
    byte vorigDagnr;
    byte dagnm;
    byte uur;
    byte vorigUur;
    byte minuut;
    String datum;
    word dagMinuten(){return 60*uur+minuut;}
    boolean eersteLeesKlok = true;

  // +++++++++ algemeen
    boolean etmaal = false;
    byte allesBinnen;
    File file1;
    File file2;
    File filei;
    int tabel[10];
                 

void setup()
  {
    // ++++++++++ setup monitor
    Serial.begin(9600);
   
    // ++++++ setup sd
    SD.begin(chipSelect);

    // +++++++ setup serieel RS485
    Serial1.begin(4800); // moet overal hetzelfde zijn.
    pinMode(ssRW, OUTPUT);
    digitalWrite(ssRW, ssOntvangen);  // Init Transceiver   
   
    //delay(stationIk*100);  // voorkomt gelijktijdige communicatie bij opstarten

// ++++++++ initiëren bestanden +++++++++++++++
   
//      datumNaarDatumbestand(String("20-07-15"));

//      SD.remove("2020-05/tst001.txt");
  //    SD.rmdir("2020-05");
//        SD.remove("stat.txt");
//        SD.remove("stat0002.stt");
//        SD.remove("stat0003.stt");
//        SD.remove("stat0004.stt");
//        SD.remove("stat0005.stt");
//        SD.remove("stat0000.stt");

//                                           123456789012345678901234567890
//      meerIndex(String("S01TEMP"), String("Weerhuisje_temperatuur"));
//      meerIndex(String("S02VOCHT"), String("weerhuisje_vochtigheid"));
//      meerIndex(String("S03BARO"), String("Regen_barometer"));
//      meerIndex(String("S04REGEN"), String("Regen_regenmeter"));


//        File f = SD.open("28-06-2020/s01temp.dat",FILE_WRITE); f.close();
//             f = SD.open("28-06-2020/s02voch.dat",FILE_WRITE); f.close();

//          maakBackupbestanden();

//        sdRename(String("20-07-16/S01TEMP.DB1"),String("20-07-16/S01TEMP.DBU"));



//        while(1);

   
  }

void loop()
  {
    // ++++++++++ data RS485 beschikbaar
   
    if(Serial1.available()>0)
      {
          leesData();
       // printData();
         
        opdracht = data[2];
        if(opdracht == 16
        || opdracht == 9
        || opdracht == 13
        || opdracht == 3
     // || opdracht == 9 // enz enz
          ) {
                ontvangVergelijkControlegetal = 0;
                verwerkTelData = 0;
             
                byte Bdump = leesByteUitData();
                stationZender = leesByteUitData();
                opdracht = leesByteUitData();
                Serial.print(F("\tzender: "));
                Serial.print(stationZender);
                Serial.print(F("\topdracht: "));
                Serial.print(opdracht);
                   
                 
              // lees opdracht in

                  byte comKeuze;
                  float Fdump;
                  int begindatum;
                  int einddatum;
                 
                  byte n1;
                 
                  switch(opdracht)
                    {
                      case 3: // klokgegevens
                        jaar   = leesByteUitData();
                        maand  = leesByteUitData();
                        dagnr  = leesByteUitData();
                        dagnm  = leesByteUitData();
                        uur    = leesByteUitData();
                        minuut = leesByteUitData();
                        if(eersteLeesKlok == true)
                          {
                            eersteLeesKlok = false;
                            //vorigJaar = jaar;
                            //vorigMaand = maand;
                            vorigUur = uur;
                            vorigDagnr = dagnr;
                          }
                    // ++++++++ elk heel uur
                        if(uur != vorigUur || (dagnr != vorigDagnr && allesBinnen &B11))
                          {
                            // maak back-up's
                            maakBackupbestanden();
                            if (dagnr != vorigDagnr) {allesBinnen |=B100;}
                            vorigUur = uur;
                          }
                   
                    // +++++ etmaal
                        if (dagnr != vorigDagnr && allesBinnen &B111)
                          {
                            // eenmalig om 00:00 uur
                               
                            // +++ bepaal datumnaam en maak map.
                                datum = String(jaar) + String("-");
                                if(maand<10) {datum+=String("0");}
                                datum += String(maand) + String("-");
                                if(dagnr<10) {datum+=String("0");}
                                datum += String(dagnr);
                                if(datum.length() != 8)
                                  {
                                     if(dataMonitor == false)
                                        {
                                          Serial.println("fout in datum");
                                        }
                                    while(1);
                                  }
                            // +++ maak volgende datumMAP.
                                if(!SD.exists(datum))
                                    {
                                      SD.mkdir(datum);
                                    }
                               
                            // +++ maak nieuw datumBESTAND
                                datumNaarDatumbestand(datum);
                             
                              vorigDagnr = dagnr;
                              allesBinnen = 0;
   
                            } // end if hh:mm = 00:00
                      break;
                   
/*                      case 10: // data om te schrijven van station 32 zonne-oog
                        datum = leesLaatsteDatumUitDatumbestand();
                       
                        String bestand = String("T01zonnn");
                       
                        String pad = String(datum) + String("/") + bestand + String(".dat");
                            File myFile1 = SD.open(pad,FILE_WRITE);
                            for(byte n=4;n<=telData-3;n+=2)  // <<<<<<<<<<<<<<< nakijken
                              {
                                byte hi = leesByteUitData();
                                byte lo = leesByteUitData();
                                word waarde = word(hi,lo);
                                int getal = zetSerieelNaarInt(waarde);
                                myFile1.println(getal);
                              }
                            myFile1.close();
                       break;
*/
                       case 9:  // opslag weerhuisje
                        if(dataMonitor == false)
                            {
                           //   Serial.print("  [ case 9 ] ");
                            }
                            datum = leesLaatsteDatumUitDatumbestand();
                            file1 = SD.open(datum+"/S01temp.dat",FILE_WRITE);
                            file2 = SD.open(datum+"/S02voch.dat",FILE_WRITE);
                            KOMMAintOpslagSD(file1, dagMinuten());
                            KOMMAintOpslagSD(file2, dagMinuten());
                            Serial.print("Dagminuten: ");
                            Serial.print(dagMinuten());
                            leesIntUitDataEnSlaOp(file1);                               
                            leesIntUitDataEnSlaOp(file2);
                            //file1.println();
                            //file2.println();
                            file1.close();
                            file2.close();
                            if (dagnr != vorigDagnr) {allesBinnen |= B1;}
                       break;

                       case 13: // regen en barometer
                          if(dataMonitor == false)
                            {
                         //     Serial.print("  [ case 13 ] ");
                            }
                            datum = leesLaatsteDatumUitDatumbestand();
                            file1 = SD.open(datum+"/S03baro.dat",FILE_WRITE);
                            file2 = SD.open(datum+"/S04regen.dat",FILE_WRITE);
                            KOMMAintOpslagSD(file1, dagMinuten());
                            KOMMAintOpslagSD(file2, dagMinuten());
                            leesIntUitDataEnSlaOp(file1); // barometer
                            Fdump = leesIntUitData();     // regen
                            leesIntUitDataEnSlaOp(file2); // regen1dag
                            leesIntUitDataEnSlaOp(file2); // regen1uur
                            leesIntUitDataEnSlaOp(file2); // regen5min
                            file1.println();
                            file2.println();
                            file1.close();
                            file2.close();
                            Fdump = leesIntUitData();     // regenTemp
                            Fdump = leesFloatUitData();   // regenfactor
                            if (dagnr != vorigDagnr) {allesBinnen |= B10;}
                        break;

                        case 16: // comandosturing vanuit bediening
                            comKeuze = leesByteUitData();
                            switch (comKeuze)
                              {
                                case 1: // overzicht SD directory
                                    toonSDboom();
                                break;

                                case 2: // toon geheel indexbestand
                                    leesGeheelIndexBestand();
                                break;

                                case 3: // toon geheel datumbestand
                                    leesGeheelDatumBestand();
                                break;

                                case 4:
                                    Serial.print(F(" Begindatum: "));
                                    Serial.print(leesIntUitData());
                                    Serial.print(F("  Einddatum: "));
                                    Serial.println(leesIntUitData());
                                break;
                               
                                case 5: // aanmaak overzicht
                                    for (byte n=1; n<10; n++)
                                      {
                                        tabel[n] = 0;
                                      }
                                    Serial.println();
                                    begindatum = leesIntUitData();
                                    einddatum = leesIntUitData();
                  Serial.println(("\t<< Regel 388 Tabel vóór invulling vóór ontvangen:"));
                  for(byte n=1; n<10; n++)
                    {
                      Serial.print("\t");
                      Serial.print(tabel[n]);
                    }
                  Serial.println();

                                    for (byte n=1; n<10; n++)
                                      {
                                        tabel[n] = leesIntUitData();
                                        if(tabel[n] == 127)
                                          {
                                            n1 = n-1;
                                          }
                                      }                 

                  Serial.print(F("<< Regel 405 Tabel na ontvangst serieel"));
                  Serial.println(F(" voor aanmaak overzichtbestand."));
                 
                  for(byte n=1; n<10; n++)
                    {
                      Serial.print("\t");
                      Serial.print(tabel[n]);
                    }
                  Serial.println();
                  Serial.print("aantal items: ");
                  Serial.println(n1);                   
                                    aanmaakOverzichtBestand(begindatum, einddatum, n1);  //, tabel[10]);
                                break;
                               
                                case 6:  // dump stat bestand op scherm
                                    //
                                    dumpStatbestandOpScherm();
                                break;
                                   
                                case 7:// dump stat bestand op scherm
                                    dumpLaatsteSTATxxxxOpScherm();
                                break;
                                   
                                case 8:
                                  toonDataOpScherm();
                                break;
                               
                                case 9:
                                    SD.remove("stat.txt");
                                break;
                               
                              }
                        break;

                  } // end switch
   
 
         // verifieer ontvangControlegetal en berichtstatus en rond af             
            oorsprOpdracht = opdracht;
            _ontvangVergelijkControlegetal = ontvangVergelijkControlegetal &127;
            ontvangControlegetal = leesByteUitData(); //ontvangControlegetal
                       
              berichtStatus = leesByteUitData(); // nog even niks mee doen
             
           
              berichtStatus = stFout;
              if(_ontvangVergelijkControlegetal == ontvangControlegetal)
                {
                  berichtStatus = stOk;
                }
             
                if(berichtStatus == stOk)
                  {
                    if(dataMonitor == false)
                      {
                        Serial.println("[Ok]");
                      }
                  }
                if(berichtStatus == stFout)
                  {
                    if(dataMonitor == false)
                        {
                          Serial.println("[FOUT!]");
                        }
                  }
           
            } // End If voor mij
             
              telData = 0;

      }  // end lees data


// data RS485 verzenden +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   
    if(zendopdracht > 0 )
      {
          zendopdracht--; // er kunnen er meer zijn
          opdracht = zendData[verzendpnt + 2];
          verzendDatabuffer();

          switch (opdracht) // extra acties na verzending indien nodig
            {
              default:
              break;
            }
      }

  } // end loop


// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// F U N C T I E S
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// ++++++++++ SD

void printsize(File _file) // geef eerst filnaam op met SD.open
  {
     Serial.print(" [ ");
     Serial.print(_file.size());
     Serial.print(" ] ");
  }


void toonSDboom() // mooiere boom, bovendien zelf aan te passen
  {
    Serial.println("\n\t----------------------------");
    Serial.println("\t| prg: project 80-13 SD BLE |");
    Serial.println("\t----------------------------\n");
        Serial.println("\t++++++++++++++++++++++++++++++++++++++++++++++++");
        File root = SD.open("/");
        printDirectory(root, 0);
        Serial.println("\t++++++++++++++++++++++++++++++++++++++++++++++++");
  }

void printDirectory(File dir, int numTabs)
  {
    boolean minTab = true;
    while (true)
      {
        File entry =  dir.openNextFile();
        if (! entry)
          {
              // no more files
              break;
          }
   
        for (byte i = 0; i < numTabs; i++)
          {
              Serial.print("\t+\t");
              minTab = false;
          }
     
        Serial.print("\t+ ");
        Serial.print(entry.name());
        if (entry.isDirectory())
          {
              Serial.println("/");
              printDirectory(entry, numTabs + 1);
          }
        else
          {
            // files have sizes, directories do not
            Serial.print("\t");
            if(minTab == true)
              {
                Serial.print("\t");
              }
            Serial.println(entry.size(), DEC);
          }
       
        entry.close();
     } // end while
  }

void leesDirMetVerwijderFile()
  {
     File root = SD.open("/");
     leesDirMetVerwijderFileNext(root);
     root.close();
  }

void leesDirMetVerwijderFileNext(File dir)
  {
     while (true)
      {
        File entry =  dir.openNextFile();
    //    if (entry == "system*")
          {
            goto skipSystem;
          }
        if (! entry)
          {
              // no more files
              break;
          }
        Serial.print(entry.name());
        if (entry.isDirectory())
          {
/*            while(digitalRead(pin6) == HIGH && digitalRead(pin7) == HIGH) {}
            if(scanDrukknop(pin6) == pin6) {}
            if(scanDrukknop(pin7) == pin7)
              {
                SD.rmdir(entry.name());
                Serial.print(" gewist");
              }
  */            Serial.println("/");
              leesDirMetVerwijderFileNext(entry);
          }
        else
          {
/*            while(digitalRead(pin6) == HIGH && digitalRead(pin7) == HIGH) {}
            if(scanDrukknop(pin6) == pin6) {}
            if(scanDrukknop(pin7) == pin7)
              {
                SD.remove(entry.name());
                SD.remove(dir.name()+String("/")+entry.name());
                Serial.print(" gewist");
              }
            Serial.println();
 */         }
        skipSystem:
        entry.close();
      }  // end while
  }

void sdRename(String _oud, String _nieuw)
  {
    SD.remove(_nieuw);
    file1 = SD.open(_oud);
    file2 = SD.open(_nieuw,FILE_WRITE);
    while (file1.available() >0)
      {
        file2.write(file1.read());
      }
    file1.close();
    file2.close();
    SD.remove(_oud);
  }
/*
String leesVolgendeStringUitbestand(File _file)
   {
     char _record[30];
     String _rec;
     int _i = -1;
    _rec = String("");
   
    while(_file.peek() != 13)
          {
            _i++;
            _record[_i] = _file.read();
            _rec += String(_record[_i]);
          }
         
        _record[0] = _file.read(); // CR = 13
        _record[0] = _file.read(); // LF = 10
     
    return _rec;
   }
*//*
int leesVolgendeIntUitbestand(File _file)
   {
    int _getal = _file.read()*256;
    if(_file.peek() != 13)
          {
            _getal += _file.read();
          }
         
        byte dummie = _file.read(); // CR = 13
             dummie = _file.read(); // LF = 10
     
    return _getal;
   }
*/
void dumpFileOpScherm_1()
   {
        int _tel = 0;
        File _T = SD.open("20-08-02/S01TEMP.DAT");
        //File _V = SD.open("20-08-02/S02VOCH.DAT");
        while(_T.available()>0)
          {
            while(_T.peek() != 44)
                {

                }
            _T.read();
        /*    Serial.print("\t");
            while(_V.peek() != 44)
                {
                  Serial.write(_V.read());
                }
             dummie = _V.read();
      */       Serial.println();
               _tel++;
          }
        _T.close();
        Serial.print("\t");
        Serial.println(_tel);
     //   _V.close();
   }

void dumpFileOpScherm_2()
   {
        File _T = SD.open("20-08-06/S01TEMP.DAT");
        File _V = SD.open("20-08-06/S02VOCH.DAT");
        int Igetal;
        boolean _min = false;
        while(_T.available() > 0)
          {
            Igetal=0;
            while(_T.peek() != 44)
              {
                if(_T.peek() == 45) // min-teken
                  {
                    _min = true;
                    _T.read();
                  }
                else
                  {
      //              Serial.print(_T.peek());
      //              Serial.print(" ");
                    Igetal = (Igetal*10) + (_T.read()-48);
                  }
              }
            if(_min == true)
              {
                _min = false;
                Igetal = -Igetal;
              }
            Serial.print(Igetal);
            Serial.print("\t");
            _T.read();//44

            Igetal=0;
            while(_V.peek() != 44)
              {
                if(_V.peek() == 45) // min-teken
                  {
                    _min = true;
                    _V.read();
                  }
                else
                  {
      //              Serial.print(_V.peek());
      //              Serial.print(" ");
                    Igetal = (Igetal*10) + (_V.read()-48);
                  }
              }
            if(_min == true)
              {
                _min = false;
                Igetal = -Igetal;
              }
            Serial.println(Igetal);
            _V.read();//44
         
          }
        _T.close();
        _V.close();
   }


void leesGeheelIndexBestand()
  {
    filei = SD.open("index.txt");
    Serial.println(F("\n\n\tINDEX-bestand."));
    Serial.println(F("\tkorte naam\tlange naam"));
    int tel = 0;
    while(filei.available() >0)
      {
        tel++;
        Serial.print(F("\t"));
        if(tel<100) {Serial.print(F(" "));}
        if(tel<10) {Serial.print(F(" "));}
        Serial.print(tel);
        Serial.print(F(" "));
        Serial.print(KOMMAstringLeesSD(filei));
        Serial.print("\t");
        Serial.println(KOMMAstringLeesSD(filei));
      }
    filei.close();
  }

int leesGeheelDatumBestand()
  {
    filei = SD.open("datum.txt");
    Serial.println(F("\n\n\tDATUM-bestand."));
    int tel = 0;
    while(filei.available() >0)
      {
        tel++;
        Serial.print(F("\t"));
        if(tel<100) {Serial.print(F(" "));}
        if(tel<10) {Serial.print(F(" "));}
        Serial.print(tel);
        Serial.print(F("  "));
        Serial.println(KOMMAstringLeesSD(filei));
      }
    filei.close();
    return tel;
  }

void leesWeerhuisjeBestand(String _datum)
  {
    file1 = SD.open(_datum+"/S01TEMP.DAT");
    file2 = SD.open(_datum+"/S02VOCH.DAT");
    float _temp;
    while(file1.available() >0)
      {
        _temp = (KOMMAfloatLeesSD(file1));
        Serial.print((_temp/10),1);
        Serial.print("\t");
        Serial.println(KOMMAintLeesSD(file2));
      }
    file1.close();
    file2.close();
  }

void meerIndex(String _nm, String _naam)
  {
    filei = SD.open("index.txt",FILE_WRITE);
    KOMMAstringOpslagSD(filei, _nm);
    KOMMAstringOpslagSD(filei, _naam);
    filei.close();
  }


void datumNaarDatumbestand(String _datum)
  {
     if(dataMonitor == false)
        {
   //       Serial.println(_datum);
        }
     filei = SD.open("datum.txt",FILE_WRITE);
     KOMMAstringOpslagSD(filei, _datum);
     filei.close();
  }
 
String leesLaatsteDatumUitDatumbestand()
  {
    filei = SD.open("datum.txt");
    String _datum;
    while(filei.available() >0)
      {
        _datum = KOMMAstringLeesSD(filei);
      }
    filei.close();
    return _datum;
  }

void maakBackupbestanden()
  {
    String _datum = leesLaatsteDatumUitDatumbestand();
   
    File _filei = SD.open("index.txt");
    byte _telBestanden = 0;
    byte _item = 1; // welk item uit bestand, 1 = bestandsnaam, 2 = volledige naam
    while(_filei.available() >0)
      {
        _telBestanden++;
        String _record = KOMMAstringLeesSD(_filei);
        if(_telBestanden == _item)
          {
            String _bestand = _datum + String("/") + _record; // + String(".ext");
            if(dataMonitor == false)
                {
        //          Serial.print(_bestand);Serial.println("]]");
                }
            if(SD.exists(_bestand + String(".dat")))
              {
                  File _file1 = SD.open(_bestand + String(".dat"));
                  File _file2 = SD.open(_bestand + String(".DB1"),FILE_WRITE);
                  while(_file1.available() >0)
                    {
                      _file2.write(_file1.read());
                    }
                  _file1.close();
                  _file2.close();
                  sdRename(_bestand + String(".DB1"),_bestand + String(".DBU"));
              }
          }
        if(_telBestanden == 2){_telBestanden = 0;}
      }
    _filei.close();
  }

void leesIntUitDataEnSlaOp(File _file)
  {
        int Igetal = leesIntUitData();
        KOMMAintOpslagSD(_file, Igetal);
  } 

void aanmaakOverzichtBestand(int _begindatum, int _einddatum, int aantalItems) //, int tabel[10])
  {
    unsigned long tijd = millis();
    // aantalItems is van 1 t/m aantalItems ! ! ! ! ! ! ! anders krijg ik veel +1 en -1
    // alle de te maken bestanden zijn komma gescheiden (excel)
    Serial.println(F("\n\t<< Begin procedure. >>"));
    File Fdata[aantalItems]; // aantal sensoren incl.
    String Sdatum;
    String index[10][2];
    int i = 0;
    String stat;
    String Sdump;
    int Idump;
    float Fdump;
    int leesAantalMinuten[10];
    int dataTabel[12];
    int Bregen = -1;
    int aantalMinuten;
   
    // VOORBEREIDING

    Serial.println(F("\n\t<< Bijschrijven in overzichtsbestand [stat.txt] >>"));
    File Foverzicht = SD.open("stat.txt",FILE_WRITE);
        // inhoud heeft vorm van STAT0001, 2x datumnr, aantalItems, tabel[10]nr ev.
        // zodat er altijd teruggekeken kan worden.

    // pointer staat nu achteraan
    // berekenen volgende statistiek-nummer
    unsigned long pos = Foverzicht.position(); // veelvoud van 34. +1 of -1 ????
    i = (pos+17) / 34;  // eventueel aanpassen, zie 10 regels verder, vlak voor close() IS AANGEPAST.
    stat = String(F("stat"));
    if(i<1000) {stat += String(F("0"));}
    if(i<100) {stat += String(F("0"));}
    if(i<10) {stat += String(F("0"));}
    stat += String(i);
    KOMMAstringOpslagSD(Foverzicht,stat);
    KOMMAintOpslagSD(Foverzicht,_begindatum);
    KOMMAintOpslagSD(Foverzicht,_einddatum);
    KOMMAintOpslagSD(Foverzicht,aantalItems);
    for(i=1; i<=9; i++)
      {
        KOMMAintOpslagSD(Foverzicht,tabel[i]);
      }
                  Serial.println(F("\t<< regel 908 Tabel ná verwerking voor stat-bestand:"));
                  for(byte n=1; n<10; n++)
                    {
                      Serial.print("\t");
                      Serial.print(tabel[n]);
                    }
                  Serial.println();
    Foverzicht.println();
    Serial.print(F("\tPointerpositie Foverzicht (regel 915): "));
    Serial.println(Foverzicht.position());
    Foverzicht.close();
//while(1);
    Serial.println(F("\n\t<< Inlezen indexbestand in tabel. [index.txt] >>"));
    File Findex = SD.open("index.txt");
    i = 1;
    while(Findex.available() >0)
      {
        index[i][0] = KOMMAstringLeesSD(Findex); // zet alle sensoren (korte naam) in tabel
        index[i][1] = KOMMAstringLeesSD(Findex); // idem lange naam
        i++;
      }
    Findex.close();

    // HET ECHTE WERK

    Serial.println(F("\n\t<< Open statistiekenbestand voor schrijven. [STATxxxx.stt >>"));
    File Fstat = SD.open(stat+String(".stt"),FILE_WRITE); // de te maken overzichtsbestand, komma gescheiden
    // kop
    Serial.print(F("\t<< Overzicht voor statistieken: "));
    Serial.println(stat);
   
    // dan de labels
    Serial.print(F("\n\t<< Labels: "));
    for(i = 1; i <= aantalItems; i++)
      {
        if(index[tabel[i]][0] == String("S04regen"))
          {
            Bregen = i;
            KOMMAstringOpslagSD(Fstat, String("Rdag,"));
            KOMMAstringOpslagSD(Fstat, String("Ruur,"));
            KOMMAstringOpslagSD(Fstat, String("R5min"));
          }
        else
          {
            KOMMAstringOpslagSD(Fstat, String(index[tabel[i]][0]));
          }
        Serial.print(F("\t"));
        Serial.print(index[tabel[i]][0]);
      }
    Fstat.println(); // einde labelrecord
    Serial.println();
   
    // DATA
   
    for(byte m = _begindatum; m <= _einddatum; m++) // aantal datums
      {
        File Fdatum = SD.open("datum.txt");
        for(i = 1; i <= m; i++)
          {
            Sdatum = KOMMAstringLeesSD(Fdatum); // haal datumString[m] op
          }
        Fdatum.close();
        Serial.print(F("\t<< Datum: "));
        Serial.println(Sdatum);
       
        for (byte n=1; n<=aantalItems; n++)
          {
            String TempFile = Sdatum+String("/")+index[tabel[n]][0]+String(".dat");
            if(!SD.exists(TempFile))
              {
                Serial.print(F(" HELP, bestaat niet (regel 977): "));
                Serial.print("[");
                Serial.println(TempFile);
                Serial.print("]");
                Fstat.close();
   /* BLOK */   while(1);
              }
            Fdata[n] = SD.open(TempFile); // open alle data-bestanden van toepassing
          }

        Serial.print(F("\n\t<< Minuten: >>"));
        for(aantalMinuten = 0; aantalMinuten <= 24*60; aantalMinuten++) // minimaal elke minuut een waarneming
          {
            if(aantalMinuten%20 == 0)
              {
                Serial.print("*");
              }
            // ( geen available, maar test op -1)
           
            for (byte n=0; n<=aantalItems; n++)
              {
                 if(aantalMinuten == leesAantalMinuten[n]) // dan overzetten
                    {
                      leesAantalMinuten[n] = KOMMAintLeesSD(Fdata[n]); // lees alvast volgende tijd
                      dataTabel[n] = KOMMAintLeesSD(Fdata[n]); // onthouden data
                      if(Bregen == n)
                        { // 2 extra items overzetten
                         
                      dataTabel[10] = KOMMAintLeesSD(Fdata[n]); // onthouden data
                      dataTabel[11] = KOMMAintLeesSD(Fdata[n]); // onthouden data
                        }
                    }
                      // overzetten of dupliceren van voorgaande,
         // alle items moeten elke minuut data plaatsen vanwege de synchronisatie van alle items.
         
                      KOMMAintOpslagSD(Fstat, dataTabel[n]);
                      if(Bregen == n)
                        { // 2 extra items overzetten
                          KOMMAintOpslagSD(Fstat, dataTabel[10]);
                          KOMMAintOpslagSD(Fstat, dataTabel[11]);
                        }
                   
                // einde overzetten of dupliceren van voorgaande
               
              } // einde aantal items

            Fstat.println(); // volgende record = volgende minuut
               
           } // einde aantal minuten = einde dag
           
            for (byte n=0; n<=aantalItems; n++)
              {
                Fdata[n].close(); // sluit alle data-bestanden van toepassing
              }
            for (byte n=0; n<=9; n++)
              {
                 leesAantalMinuten[n] = 0; // terug naar 00:00 uur
              }
           
            Serial.println();
           
        } // einde datum = volgende dag

      Fstat.close();
      Serial.print(F("\t<< looptijd aanmaak overzicht bestand: "));
      Serial.print(millis() - tijd);
      Serial.println(F("mS >>"));
 
  } // einde void aanmaakOverzichtBestand

/*void stringOpslaanSD(File _f, String _string)
  {
    char _teken;
    for (byte n=0; n <= _string.length()-1; n++)
      {
 //       _teken = _string.substring(n,n+1);
 //       _f.write(_teken);
          _f.print(_string.substring(n,n+1));
      }
  }

void stringOpslaanSD(File _f, String _string)
  {
     for(byte n=1; n<= _string.length(); n++)
      {
        _f.write(_string.substring(n,n+1));
      }
  }

void intOpslaanSD(File _f, int _getal)
  {
      _f.write(highByte(_getal));
      _f.write(lowByte(_getal));
  }

int intLeesSD(File _f)
  {
      int _getal;
      byte high = _f.read();
      byte low = _f.read();
      if(high & 128)
        {
          high = ~high;
          low = ~low;
          _getal = -(high*256 + low +1);
        }
      else
        {
          _getal = high*256 + low;
        }
      return _getal;
  }
*/
void dumpLaatsteSTATxxxxOpScherm()
  {
    unsigned long tijd = millis();
    Serial.print(F("\t<< Kijk naar <laatste> bestand in overzicht: "));
    String stat;
    String Sdump;
   
    File Foverzicht = SD.open("stat.txt");
        // inhoud heeft vorm van STAT0001, 2x datumnr, aantalItems, (tabel[10]nr ev.)

    while(Foverzicht.available() >0)
      {
        stat = KOMMAstringLeesSD(Foverzicht);
        for (byte n=1; n<= 12; n++)
          {
            Sdump = KOMMAintLeesSD(Foverzicht);
          }
      }
    Foverzicht.close();
   
    stat = stat + String(".STT");
    Serial.println(stat);
    File Fstat = SD.open(stat);
    while(Fstat.available() >0)
      {
        Serial.write(Fstat.read());
      }
    Fstat.close();
      Serial.print(F("\t<< looptijd dump op scherm: "));
      Serial.print(millis() - tijd);
      Serial.println(F("mS >>"));
  }

void dumpStatbestandOpScherm()
  {
    unsigned long tijd = millis();
    Serial.print(F("\n\t<< Kijk naar <laatste> bestand in overzicht: "));
    String stat;
    String Sdump;
    stat = String("stat.txt"); // even forceren.
    //stat = stat + String(".STT");
    Serial.println(stat);
    File Fstat = SD.open(stat);
    while(Fstat.available() >0)
      {
        for (byte n=1; n<=8; n++) // statnaam
          {
            Serial.write(Fstat.read());
          }
        Serial.println();
        for (byte n=1; n<=12; n++)
          {
            Serial.println(KOMMAintLeesSD(Fstat));
          }
      }
    Fstat.close();
      Serial.print(F("\t<< looptijd dump op scherm: "));
      Serial.print(millis() - tijd);
      Serial.println(F("mS >>"));
  }

void toonDataOpScherm()
  {
    File _fi = SD.open("20-11-12/S01TEMP.DAT");
    while(_fi.available() > 0)
      {
        Serial.write(KOMMAintLeesSD(_fi));
        Serial.write(KOMMAintLeesSD(_fi));       
        Serial.println();
      }
    _fi.close();
  }

// ++++++++++++++++++++++++++++++++++++++++
// NIEUWE KOMMA-GESCHEIDEN OPSLAG FUNCTIES.
// ++++++++++++++++++++++++++++++++++++++++
void KOMMAbyteOpslagSD(File _f, byte _item)
  {
    _f.write(_item);
    _f.write(44);
  }
void KOMMAintOpslagSD(File _f, int _item)
  {
    _f.write(highByte(_item));
    _f.write(lowByte(_item));
//    _f.write(44);

//2   _f.print(highByte(_item));
//    _f.print(lowByte(_item));
//    _f.print(char(44));
   
//    _f.print(highByte(_item));
//    _f.print(lowByte(_item));
  }
void KOMMAfloatOpslagSD(File _f, float _item)
  {
    _f.write(44);
  }
void KOMMAstringOpslagSD(File _f, String _item)
  {
    for(byte n=0; n <= _item.length(); n++)
      {
        _f.print(_item.substring(n,n+1));
      }
    _f.write(44);
  }
byte KOMMAbyteLeesSD(File _f)
  {
     return _f.read();
  }
int KOMMAintLeesSD(File _f)
  {
      int _getal;
      byte high = _f.read();
      byte low = _f.read();
      if(high & 128)
        {
          high = ~high;
          low = ~low;
          _getal = -(high*256 + low +1);
        }
      else
        {
          _getal = high*256 + low;
        }
      return _getal;
  }
float KOMMAfloatLeesSD(File _f)
  {
  }
String KOMMAstringLeesSD(File _f)
  {
    char _rec[50];
    String _item;
    int _i = -1;
    while(_f.peek() != 44)
      {
        _i++;
        _rec[_i] = _f.read();
        _item += String(_rec[_i]);
      }
     char dummie = _f.read();
     return _item;
  }
// ++++++++++++++++++++++++++++++++++++++++++++++
// NIEUWE KOMMA-GESCHEIDEN OPSLAG FUNCTIES. einde
// ++++++++++++++++++++++++++++++++++++++++++++++

 
// Serial

void leesData() // naar Buffer
  {
    telData = 0; // was vroeger 1.
    int woord;
    do
      {
        while(Serial1.available() == 0) {}
        woord = Serial1.read();
        data[telData] = byte(woord);
        telData++;
      }
    while(woord < 128 && woord >= 0 && telData <= 64);
  }

void printData()
{
  Serial.println();
  for(byte n = 0; n <= telData-1; n++)
    {
      if(n/10 == n%10 && n!=0)
        {
          Serial.print("\n\t");
        }
      Serial.print(data[n]);
      Serial.print("\t");
    }
  Serial.println();
}

byte leesByteUitData()

    {
      byte byteOntvangen = data[verwerkTelData];   // Read the byte
      verwerkTelData++;
      ontvangVergelijkControlegetal = (ontvangVergelijkControlegetal + byteOntvangen) &127;
      return byteOntvangen;
    }

int leesIntUitData()
  {
    byte hi = leesByteUitData();
    byte lo = leesByteUitData();
    word _getal = word(hi,lo);
    int intGetal = zetSerieelNaarInt(_getal);
    return intGetal;
  }

float leesFloatUitData()
  {
    // via String
    String Sgetal;
    while(data[verwerkTelData] != 127) // 127 is eind-waarde
      {
        Sgetal += char(leesByteUitData());
      }
    return Sgetal.toFloat();
  }

void verzendDatabuffer() // aangepast versie 4 beta
  {
    digitalWrite(ssRW, ssZenden);  // Enable RS485 Transmit
    Serial.println("\tzend");

    byte woord;
    do
      {
        woord = zendData[verzendpnt&63];
        Serial1.write(woord);
        verzendpnt = (verzendpnt + 1) & 63;
      }
    while(woord < 128);
   
    if(zendopdracht == 0) // als alle data verwerkt, want er kan meer zijn.
      {
        verzendpnt = 0;
        vulZendpnt = 0;
      }
   
    digitalWrite(ssRW, ssOntvangen);  // Disable SSRS485 Transmit 
  }


 word zetIntNaarSerieel(int _getal)
  {
    word g1(abs(_getal));
    g1 *= 2;  // 1 bit opschuiven
    byte _hi = highByte(g1);
    byte _lo = lowByte(g1);
    _hi *= 2;
    bitWrite(_hi,0,bitRead(_lo,7));
    bitClear(_lo,7);
    bitClear(_hi,7);
    if(_getal < 0)
      {
        bitSet(_lo,0);  // negatief-bit
      }
    //controlegetal = (controlegetal+_hi)&127; // ???????????
    //controlegetal = (controlegetal+_lo)&127; // ???????????
    return word(_hi&127,_lo&127);
  }

int zetSerieelNaarInt(word _Swaarde)
  {
    byte _hi = highByte(_Swaarde);
    byte _lo = lowByte(_Swaarde);
    byte neg = bitRead(_lo,0); // negatief bit
    _lo *= 2;
    word g1 = word(_hi,_lo);
    g1 /= 4;
    int g2 = int(g1);
    if(neg == 1)
      {
        g2 = -g2;
      }
    return g2;
  }

// bufferacties

void zetByteInBuffer(byte _teken) // aangepast versie 4 beta
  {
    zendData[vulZendpnt] = _teken;
    zendControlegetal = (zendControlegetal + _teken) & 127;
    vulZendpnt = (vulZendpnt + 1) & 63;
  }

void zetIntInBuffer(int _sensor) // aangepast versie 4 beta
  {
    word _waarde = zetIntNaarSerieel(_sensor);
    zetByteInBuffer(highByte(_waarde));
    zetByteInBuffer(lowByte(_waarde));
  }


 

Gebruikers-avatar
Berichten: 2655
Geregistreerd: 06 Aug 2016, 01:03

Re: vastloper op serial.print

Berichtdoor Koepel » 12 Nov 2020, 18:14

Het is teveel om goed te bekijken, maar er zijn een paar dingen die opvallen.

Dit is vreemd, je zet commentaar voor het if-statement, zodat altijd de goto wordt uitgevoerd. Vervolgens moet je wel een entry.close() doen, omdat het een geldige file handle zou kunnen zijn. Op die manier komt het de structuur van de code niet ten goede.

Uiteindelijk gebeurt er alleen dit:
Code: Alles selecteren
void leesDirMetVerwijderFileNext(File dir)
{
  File entry =  dir.openNextFile();
  entry.close();
}


Een lege while met een peek() gaat niet werken in de functie "dumpFileOpScherm_1()":
Code: Alles selecteren
// Je hebt dit:
while (_T.peek() != 44) {}
_T.read();

// Dit is hetzelfde
while (_T.peek() != ',');  // zolang geen komma: doe niets
_T.read();

De peek() leest niet het teken weg van de stream. Dus als er een teken is dat geen komma is, dan blijft het while-statement daar hangen en stopt de sketch.
Kun je daar ',' gebruiken in plaats van 44. Dat is beter voor de leesbaarheid.
45 is een '-'
48 is een '0'

Het valt op dat je veel met String doet en met het formatteren van tekst en met de datum.
Ik durf niet aan te geven hoe dat efficiënter kan, want met een foutje kloppen de namen van de bestanden niet meer :?

Ga je in de functie "KOMMAintLeesSD()" een negatief getal opnieuw opbouwen ? Dat lijkt me niet nodig. Het zullen toch wel twee bytes zijn die al 2's complement zijn ? Dan kun je gewoon in een int16_t zetten (met pointer of union of macro). Ik zou een union gebruiken als je zeker wilt zijn dat de eerste byte de MSB is.
Ook in "zetSerieelNaarInt()" gebeurt iets met een negatief getal wat ik niet begrijp. Kun je boven die functie zetten hoe de bits van plaats veranderen ?

In de functie "leesData()" heb je dit:
Code: Alles selecteren
while (Serial1.available() == 0) {}
Dan kan dus iets van buitenaf de sketch stil leggen. Stel dat er een draadje los zit. In de loop() wordt "leesData()" aangeroepen als er een byte binnen is. Als daarna niets meer binnen komt, dan blijft stopt de sketch op het while-statement.
Ik heb liever dat je in de loop() kijkt of er een byte binnen is, en die dan in een buffer plaatsen. Als de hele regel binnen is, dan de gegevens verwerken.

Iets vergelijkbaars gebeurt in "verzendDatabuffer()". Met een "while (woord < 128)" ga je er van uit dat 'woord' een keer 128 of groter is. Maar wat als dat niet zo is ?

Berichten: 50
Geregistreerd: 09 Jun 2020, 22:11
Woonplaats: Roosendaal

Re: vastloper op serial.print

Berichtdoor Frans53! » 12 Nov 2020, 21:20

Bedankt voor je adviezen.

Dit programma is nog behoorlijk "under construction". Vandaar dat er heel erg veel commentaar in zit, evenals de nodige teksten op de monitor.

Ook een while(1) zitten er hier en daar in om zeker te weten dat het programma afbreekt (soort van testmodus). Commentaar daarvoor is om die situatie eruit te laten springen. Later verdwijnen die whiles met commentaar.

Lees directory in welke vorm dan ook is uit de voorbeelden van de SD bibliotheek. Het kostte me heel wat hoofdbrekens om te begrijpen wat er gebeurd. Uiteindelijk doet het wat het moet doen.

Een goto gebruik ik om een deel te herhalen bij foutieve invoer, bijvoorbeeld van het bedieningspaneel.

De peek met de while werken inderdaad niet. Maar die dump-routine wordt nergens meer aangeroepen. Vroeger stond daarna nog het nodige tussen de accolades. Maar zoals ik al zei, programma is under construction.
Er staan nog veel meer functies in dat later in commentaar is gezet, en daarmee niet meer in gebruik. En zo kan ik nog een terugkijken.
Zo ben ik ook bezig geweest om op de één of andere manier bestanden te creeeren voor excel, dus komma gescheiden. De 'nieuwe' funties KOMMAxxxxxx zij daaruit voortgekomen. Dat is nog volop in ontwikkeling. Ik denk zelfs dat het me niet gaat lukken. Het eenvoudigste is om een "statistiekenbestand" samen te stellen, dat al grotendeels klaar is, die ik dan op het scherm toon. Van daaruit kan ik met copie en plak naar bijvoorbeeld kladblok, en van daaruit rechtstreeks naar exel brengen.

De punt-komma direct na een while of for beeindigd de functie, dat heb ik met schade en schande ontdekt. :D

De String heb ik proefondervindelijk vastgesteld. De SD is heel erg kritisch. En met heel veel uitproberen leek me dat toch het beste. Want mijn opgeslagen bytes mogen niet groter zijn dan 127, omdat het MSB een stopbit is in de serial. En dat kon ik niet anders krijgen. Vandaar de rare funties om maar het MSB 0 te houden bij verzending. Een float kan je dan beter in een String zetten. Een integer gaat eerst door de mallemolen om het MSB 0 te houden. Vandaar die "zetSerieelNaarInt()" , en andersom.

de while (Serial1.available() == 0) {} heb ik altijd nodig, omdat het programma af en toe sneller is dan de data binnen komt. En dan mis je data. Ook door schade en schande.

De "while (woord < 128)" heb ik in feite al uitgelegd, ik maak zelf het in laatste byte |128 als stopbit voor mijn datatrein. En dat werkt voortreffelijk. Vandaar de vele &'s |'s 127's 128's in de serial handlings.

LeesData haalt altijd eerst de hele trein binnen, soms twee, voordat het wordt verwerkt. Zenden van data gebeurt hetzelfde, maar daar heb ik twee rondraaiende poiners in gebruik, één voor schrijven, één voor verzenden, omdat het vaak voorkomt dat er twee datatreinen direkt achter elkaar worden aangeleverd voordat in de loop() de data wordt verzonden.

En zo heb ik voor heel veel rare dingen vaak wel een reden om het zo te doen.

Trouwens, weet jij een andere manier om te kijken of je alle binnenkomende data binnen hebt? Bij RS-systemen hebben ze het altijd over stopbits enzo, maar die zie ik hier niet.

Groet,
Frans.

Berichten: 50
Geregistreerd: 09 Jun 2020, 22:11
Woonplaats: Roosendaal

Re: vastloper op serial.print

Berichtdoor Frans53! » 12 Nov 2020, 21:32

Nog een vraagje:
Ik heb heel veel behoefte om bibliotheken te maken. Maar ik snap niet helemaal de werking ervan. Tevens is me niet duidelijk in welke taal het is geschreven, dan zou ik daarin lessen kunnen gaan volgen (lang leve internet).
Ik kan zelf wel stukjes schrijven in gewoon "arduino-taal" en via kladblok in een .h bestand zetten, maar die moet ik altijd in dezelfde directory zetten als de sketch. En als ik de sketch omdoop naar een volgende versie, dan snap ik helemaal niet meer hoe arduino IDE de .h bestanden behandelt. Bovendien krijg ik op een gegeven moment tabbladen erbij in de IDE met die .h bestanden. Ik ben er maar mee opgehouden.

Berichten: 50
Geregistreerd: 09 Jun 2020, 22:11
Woonplaats: Roosendaal

Re: vastloper op serial.print

Berichtdoor Frans53! » 12 Nov 2020, 21:42

Nog een vraag:

Code: Alles selecteren
void aanmaakOverzichtBestand(int _begindatum, int _einddatum, int aantalItems) //, int tabel[10])


Hoe krijg ik de tabel binnen de haken werkend?? Mij lukt het niet. (staat nu klaar om erin te klimmen :D )

Volgende

Terug naar Arduino software

Wie is er online?

Gebruikers in dit forum: Geen geregistreerde gebruikers en 3 gasten