Grafiek op Nextion HMI

Ben bezig met een project om aquarium waterwaardes weer te geven op een Nextion display. Het realtime uitlezen is inmiddels werkend. Mede met dank aan dit forum!

Nu wil ik verder met het weergeven van grafieken van deze waarden (o.a. temp, pH, geleidbaarheid), die ook de historie laat zien en liefst ook nog ergens opslaat. De standaard grafiek-module in Nextion begint echter elke keer met een leeg assenstelsel.

Wat ik dus zou willen is dat de data ergens (kan dat in Arduino zelf? moet dat op een SD-kaartje?) weggeschreven wordt en op het moment dat ik op de grafiek-knop klik, moeten de waardes weergegeven worden die opgeslagen zijn.

Nu heb ik van Nextion nog niet alles door.

De volgende vragen:

  • Is het mogelijk om zonder een SD kaart waardes op te slaan in het geheugen van arduino (UNO) zelf?
  • Zo ja, kun je daar PROGMEM voor gebruiken? En hoeveel ruimte heb je daarvoor op een UNO? Ik zie namelijk Flash Memory, SRAM en EEPROM staan in de specs.
  • In Nextion moet een deel van het mooie display niet zozeer geprogrammeerd worden, dan wel als plaatje geupload. Betekent dat dat een mooie grafiek alleen mogelijk is als ik alleen de 'lijn' weergeef en heel het raster met assenstelsels als plaatje daarachter moet plakken? Heeft iemand daar ervaring mee?

Wie kan me een duw in de goede richting geven?

Vriendelijke groet, Johan

Hoi jmnijsse.

Bij jouw verhaal moest ik meteen denken aan een data logger shield. Daar zijn er heel veel van, ook voor een schijntje uit China. Die hebben allemaal een SD card slot (kunnen wel voor verschillende fysieke afmetingen bedoeld zijn), een Real Time Clock chip, plus een batterij al dan niet in een houder die er voor zorgt dat de klok ook blijft door "tikken" als het geheel zonder spanning zit. Soms zit er nog meer nuttigs op, zoals level shifters .

Het gebruiken van een SD kaartje geeft je een gigantische hoeveelheid opslag als je het vergelijkt met het beschikbare geheugen op welke Arduino variant dan ook. Want geheugen is een achilleshiel voor de Arduino. En bovendien is een kaart niet vluchtig geheugen, en vaker overschrijfbaar dan het geheugen van je Arduino.

Over de Nextion kan ik je helemaal niets vertellen, daar verwacht ik dat Nico wel bovenop zal springen..

Als je op een WaveForm in een keer een grafiek wil laten zien met recente data zul je die inderdaad moeten opslaan. Dat kan in een Array (als je voldoende geheugen hebt. MAAR.... Dan moet je ook pointers gaan bij houden om een soort ringbuffer te maken. Een die het begin aangeeft en een die het einde aangeeft. Immers je gaat een array vullen beginnend bij index 0 tot het einde van de tabel. Daarna ga je weer de eerste waarde overschrijven. Dus moet je bijhouden waar het begin en het einde van de reeks is in de tabel.

Op het moment dat je de grafiek (waveform) wil laten zien bouw je hem op en ga je de array uitlezen. Ook hier maak je weer gebruik van de pointers om de juiste volgorde te houden.

Op een SD kaart kan je hetzelfde geintje doen door een bestand te maken en elke waarde weg te schrijven. Zou je dit volg-ordelijk doen dan blijft hij de data achteraan wegschrijven. Op enig moment is de SD kaart vol en dat lijkt mij niet wenselijk. Wat wel kan is tijdens de setup() een leeg bestand maken met x maal het aantal datapunten dat je wilt laten zien op de grafiek. De waarden kunnen dan gewoon 0 zijn.

Met de seek() functie kan je overal midden in de SD file prikken en de variabele lezen. Maar ook schrijven (write() functie).

Er zijn wel wat voorbeelden uit het verleden te vinden die de seek() gebruiken om te lezen. Om te schrijven zag ik niet zoveel.

Je hebt dus nog al wat zaken uit te zoeken:

  • maak een array en kijk of je het ringbuffer idee erin geimplementeerd krijg
  • schrijf de array naar het nextion scherm
  • Als dat allemaal lukt bouw om naar SD kaart
  • Kijk of je daar ook kan schrijven en lezen gebruik makend van de write(), read() en seek() functies.
  • Lukt dat ga dan pas jouw programma aanpassen.

Het had mooi geweest als iemand een keer een mooie library had gemaakt (wie weet is die er al). Het zou betekenen dat je met arrays kan werken ter grootte van een SD kaart).... op een eenvoudige Arduino.

Bedankt voor de reacties. Ik dacht dat ik wel een melding zou krijgen dat er gereageerd was, maar niet dus...

Ik zat idd ook al aan een SD shield te denken, maar begreep niet hoe dat via Arduino aan een Nextion gekoppeld kon worden.

Nu heb ik dus dit om een temperatuurgrafiek te krijgen:

void get_temp() 
{
  
  sensors.requestTemperatures();

  float t = sensors.getTempCByIndex(0);

  //convert to char
  char temperatureCTemp[6];
  dtostrf(t, 5, 1, temperatureCTemp);

  //update display
  tTempC.setText(temperatureCTemp);

  ch0_data = t;

  wGraph.addValue(0, ch0_data);

}

Maar i.p.v. die laatste regel moet niet slechts één ch0_data weggeschreven worden, maar dus een hele array.

Als ik je verhaal zo lees, Nico, zal dit niet eenvoudig worden voor een niet-heel-ervaren programmeur. Maar ik ben aan dit project begonnen om er iets nieuws van te leren dus ik ga eens in de wereld van pointers en ringbuffers duiken.

Dank voor de duw!

Gr. johan

Een plaatje maken vooraf helpt heel veel voor het oplossen van een probleem

Hier heb je ff een test programma met een ringbuffer.

/*
    Name:      SDArray.ino
    Created:   6-12-2018 08:41:43
    Author:     nico verduin
    Brief:        Eenvoudige manier om met een array  een ringbuffer te maken
*/

// programma constantes
const uint16_t ARRAY_SIZE = 10;     // we gaan een array maken van 10 entries

// globale variabelen
uint16_t beginIndex   = 0;                 // startpunt van de ring buffer
uint16_t eindIndex  = 0;                    // eindpunt van de ring buffer
double   array[ARRAY_SIZE];            // creer onze tabel

/*
 * @name addEntry
 * @param value double die aan de tabel wordt toegevoegd
 * @brief voegt een waarde toe aan de tabel. Als de tabel vol is, wordt de oudste waarde overschreden 
 */
void addEntry(double value) {

    // voeg de waarde toe op de laatste plek
    array[eindIndex] = value;

    // verhoog naar nieuwe laatste plek en loop around als we op het einde zitten
    eindIndex++;
    eindIndex = eindIndex % ARRAY_SIZE;         // meest eenvoudige loop around
    beginIndex++;
    beginIndex = beginIndex % ARRAY_SIZE;
}

/*
* @name getEntry
* @param index index in de array waarvan we de waarde willen hebben
* @returns double
* @brief Geeft de waarde terug uit de tabel relatief tov de eerste waarde.
*/
double getEntry(uint16_t index) {

    // reken de index om naar de juiste plek in de array
    uint16_t berekendeIndex = beginIndex + index;

    // modulo nemen en restwaarde gebruiken
    berekendeIndex = berekendeIndex % ARRAY_SIZE;

    // en geef de waarde maar terug
    return array[berekendeIndex];;
}

/*
 * @name printArray
 * @brief  print de tabel uit
 */
void printArray() {

    char floatAsString[6];      // buffer voor float conversie
    for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
        dtostrf(getEntry(i), 5, 1, floatAsString);
        Serial.print(floatAsString);
        Serial.print(" ");
    }
    Serial.println();
}
/* 
 * @name setup()
 * @brief Initializes the program
 */
void setup()
{
    // initialiseer Serial
    Serial.begin(115200);

    // initialiseer onze tabel
    for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
        array[i] = 0.0;
    }

    // vul onze tabel met wat random waarden
    randomSeed(analogRead(0));
    for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
        addEntry((double)random(0, 99) / 10.0);
    }

    // print de array
    printArray();

    // voeg nu 5 nieuwe waardes toe
    for (uint16_t i = 0; i < 5; i++) {
        addEntry((double)random(0, 99) / 10.0);

        // en print de tabel elke keer opnieuw uit
        printArray();
    }

}

// Add the main program code into the continuous loop() function
void loop()
{


}

Er zat nog een klein foutje in als de tabel nog niet helemaal is opgevuld. IS nu opgelost

/*
    Name:       SDArray.ino
    Created:    6-12-2018 08:41:43
    Author:     nico verduin
    Brief:      Eenvoudige manier om met een array  een ringbuffer te maken
*/

// programma constantes
const uint16_t ARRAY_SIZE = 15;        // we gaan een array maken van 10 entries

// globale variabelen
uint16_t beginIndex = 0;               // startpunt van de ring buffer
uint16_t eindIndex    = 0;             // eindpunt van de ring buffer
double   array[ARRAY_SIZE];            // creer onze tabel

/*
 * @name addEntry
 * @param value double die aan de tabel wordt toegevoegd
 * @brief voegt een waarde toe aan de tabel. Als de tabel vol is, wordt de oudste waarde overschreden 
 */
void addEntry(double value) {
    static bool loopAround = false;                // nodig voor het afvangen als de tabel nog nooit is gevuld of deels

    // voeg de waarde toe op de laatste plek
    array[eindIndex] = value;

    // verhoog naar nieuwe laatste plek en loop around als we op het einde zitten
    eindIndex++;
    if (eindIndex == ARRAY_SIZE) {
        loopAround = true;                        // de tabel is vol
    }
    eindIndex = eindIndex % ARRAY_SIZE;           // meest eenvoudige loop around

    // pas doen als de tabel helemaal vol is
    if (loopAround) {
        beginIndex++;
        beginIndex = beginIndex % ARRAY_SIZE;
    }
}

/*
* @name getEntry
* @param index index in de array waarvan we de waarde willen hebben
* @returns double
* @brief Geeft de waarde terug uit de tabel relatief tov de eerste waarde.
*/
double getEntry(uint16_t index) {

    // reken de index om naar de juiste plek in de array
    uint16_t berekendeIndex = beginIndex + index;

    // modulo nemen en restwaarde gebruiken
    berekendeIndex = berekendeIndex % ARRAY_SIZE;

    // en geef de waarde maar terug
    return array[berekendeIndex];;
}

/*
 * @name printArray
 * @brief  print de tabel uit
 */
void printArray() {

    char floatAsString[6];        // buffer voor float conversie

    for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
        dtostrf(getEntry(i), 5, 1, floatAsString);
        Serial.print(floatAsString);
        Serial.print(" ");
    }
    Serial.println();
}
/* 
 * @name setup()
 * @brief Initializes the program
 */
void setup()
{
    // initialiseer Serial
    Serial.begin(115200);

    // initialiseer onze tabel
    for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
        array[i] = 0.0;
    }

    // vul onze tabel met wat random waarden. Laat de laatste 3 waarden nog ff leeg
    randomSeed(analogRead(0));
    for (uint16_t i = 0; i < (ARRAY_SIZE - 3); i++) {
        addEntry((double)random(0, 99) / 10.0);
    }

    // print de array
    printArray();

    // voeg nu 5 nieuwe waardes toe
    for (uint16_t i = 0; i < 5; i++) {
        addEntry((double)random(0, 99) / 10.0);

        // en print de tabel elke keer opnieuw uit
        printArray();
    }
}

// Add the main program code into the continuous loop() function
void loop()
{
}

Zo, bedankt Nico. Dit is wel helder, al moet ik het allemaal nog gaan toepassen in mijn eigen code. Komende weken, hopelijk.

Even voor m'n begrip:

Een ringbuffer is een buffer (soort array van sensorwaarden in mijn geval) die de eigenschap heeft dat als hij vol is, de oudste waarde weer overschreven wordt?

Wat is het voordeel om uint16_t te gebruiken? Terwijl er toch eigenlijk kleine getallen in staan? Waarom niet gewoon int?

Bedankt voor het meedenken. Moeilijk, maar wel interessant.

Goed weekend alvast!

J.

Een int is een signed integer en loopt van -32767 tot +32768. Dat alleen al is eigenlijk fout omdat je geen negatieve index kan hebben in een array.
uint16_t is hetzelfde als een int op de 8bit arduino. Op een 32bit machine is hij nog steeds 16bit. Terwijl een gewone int ineens 32bits is geworden. En als je speciale berekeningen doet oid is jouw uitgangspunt weg.

uint16_t is hetzelfde als een int op de 8bit arduino.

u in uint16_t staat voor unsigned en gaat dus van 0 to 65.535 Das dus niet hetzelfde als int op 8 bit processoren die gaan van -32767 tot +32768

Een int is een signed integer en loopt van -32767 tot +32768. Dat alleen al is eigenlijk fout omdat je geen negatieve index kan hebben in een array. int16_t is hetzelfde als een int op de 8bit arduino. Op een 32bit machine is hij nog steeds 16bit. Terwijl een gewone int ineens 32bits (iets van +/- 2^31)is geworden. En als je speciale berekeningen doet oid is je uitgangspunt weg

Dank je Jan... zat ff te pitten

Ik denk doe 's en schrijf een library om maar gelijk die arrays op een SD te laten werken. Inmiddels werkt het alleen nu nog alleen voor unsigned ints (4 bytes). Ik hem nog generaliseren voor elk type variabele en de code nog netter maken. Maar de resultaten zijn veelbelovend. Getest op een gewone UNO met een oud 256mb sd kaartje uit het jaar 0 :)

____________________________________________________________
     10 records to file      W10 created in      0.002 seconds
     10 records initialized in ............      0.005 seconds
     10 records read in ...................      0.002 seconds
      1 record random read in .............      0.000 seconds
____________________________________________________________
    100 records to file     W100 created in      0.003 seconds
    100 records initialized in ............      0.014 seconds
    100 records read in ...................      0.018 seconds
      1 record random read in .............      0.001 seconds
____________________________________________________________
   1000 records to file    W1000 created in      0.004 seconds
   1000 records initialized in ............      0.137 seconds
   1000 records read in ...................      0.198 seconds
      1 record random read in .............      0.003 seconds
____________________________________________________________
  10000 records to file   W10000 created in      0.005 seconds
  10000 records initialized in ............      1.367 seconds
  10000 records read in ...................      1.974 seconds
      1 record random read in .............      0.003 seconds
____________________________________________________________
 100000 records to file  W100000 created in      0.006 seconds
 100000 records initialized in ............     13.723 seconds
 100000 records read in ...................     19.734 seconds
      1 record random read in .............      0.005 seconds
____________________________________________________________
1000000 records to file W1000000 created in      0.010 seconds
1000000 records initialized in ............    136.413 seconds
1000000 records read in ...................    197.318 seconds
      1 record random read in .............      0.009 seconds

Ik snap het niet helemaal. Ik heb de code wat aangepast. Excuses dat ik mogelijk heel lompe dingen gedaan heb.

/*
    Name:       SDArray.ino
    Created:    6-12-2018 08:41:43
    Author:     nico verduin
    Brief:      Eenvoudige manier om met een array  een ringbuffer te maken
*/

// Temperatuursensor 
#include 
#include 

#define ONE_WIRE_BUS 2

OneWire oneWire(ONE_WIRE_BUS);

DallasTemperature temp(&oneWire);

// programma constantes
const uint16_t ARRAY_SIZE = 15;        // we gaan een array maken van 10 entries

// globale variabelen
uint16_t beginIndex = 0;               // startpunt van de ring buffer
uint16_t eindIndex    = 0;             // eindpunt van de ring buffer
double array[ARRAY_SIZE];            // creer onze tabel

/*
   @name addEntry
   @param value double die aan de tabel wordt toegevoegd
   @brief voegt een waarde toe aan de tabel. Als de tabel vol is, wordt de oudste waarde overschreden
*/
void addEntry(double value) {
  static bool loopAround = false;                // nodig voor het afvangen als de tabel nog nooit is gevuld of deels

  // voeg de waarde toe op de laatste plek
  array[eindIndex] = value;

  // verhoog naar nieuwe laatste plek en loop around als we op het einde zitten
  eindIndex++;
  if (eindIndex == ARRAY_SIZE) {
    loopAround = true;                        // de tabel is vol
  }
  eindIndex = eindIndex % ARRAY_SIZE;           // meest eenvoudige loop around

  // pas doen als de tabel helemaal vol is
  if (loopAround) {
    beginIndex++;
    beginIndex = beginIndex % ARRAY_SIZE;
  }
}

/*
  @name getEntry
  @param index index in de array waarvan we de waarde willen hebben
  @returns double
  @brief Geeft de waarde terug uit de tabel relatief tov de eerste waarde.
*/
double getEntry(uint16_t index) {

  // reken de index om naar de juiste plek in de array
  uint16_t berekendeIndex = beginIndex + index;

  // modulo nemen en restwaarde gebruiken
  berekendeIndex = berekendeIndex % ARRAY_SIZE;

  // en geef de waarde maar terug
  return array[berekendeIndex];;
}

/*
   @name printArray
   @brief  print de tabel uit
*/
void printArray() {

  char floatAsString[6];        // buffer voor float conversie

  for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
    dtostrf(getEntry(i), 5, 1, floatAsString);
    Serial.print(floatAsString);
    Serial.print(" ");
  }
  Serial.println();
}
/*
   @name setup()
   @brief Initializes the program
*/
void setup()
{
  // initialiseer Serial
  Serial.begin(115200);
  // start temp-sensor
  temp.begin();

  // initialiseer onze tabel
  for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
    array[i] = 0.0;
  }
}

void loop()
{
// vul de tabel met waarden van de DS18B20.

  for (uint16_t i = 0; i < (ARRAY_SIZE); i++) {
    temp.requestTemperatures();                     
    addEntry((double)temp.getTempCByIndex(0));
    delay(2000);
    printArray();

    //als de array vol is, zet alle indexen weer op 0
    
    if (i == ARRAY_SIZE) {
      for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
        array[i] = 0.0;
      }
    }
  }
}

Nu verwacht ik dat de temperatuur één voor één de array in gestopt wordt. En dat gebeurt ook. Maar als de array vol is (bijv. na een week), wil ik weer allemaal 0-en en opnieuw beginnen. Anders krijg je een vreemde grafiek waarvan de eerste helft de afgelopen paar dagen geweest zijn en de laatste helft van vorige week.

Ik heb de meting laten lopen en bij rij 13 ongeveer de temperatuur laten dalen, maar hij lijkt vanaf rij 14 o.i.d achteruit terug te gaan.

 25.3   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4   0.0 
 25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  25.3 
 25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  25.5 
 25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  25.4 
 25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  25.4 
 25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  25.4 
 25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  25.3 
 25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  25.2 
 25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  20.7  25.3 
 25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  20.7  20.5  25.3 
 25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  20.7  20.5  20.4  25.1 
 25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  20.7  20.5  20.4  20.4  25.2 
 24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  20.7  20.5  20.4  20.4  20.4  25.1

Ik kan het niet precies verklaren.

Wat is de werking precies van de coderegels in de addEntry-functie? Mij leek daar iets te zitten wat niet goed gaat of wat ik niet begrijp, speciaal die %.

if (eindIndex == ARRAY_SIZE) {
    loopAround = true;                        // de tabel is vol
  }
  eindIndex = eindIndex % ARRAY_SIZE;           // meest eenvoudige loop around

  // pas doen als de tabel helemaal vol is
  if (loopAround) {
    beginIndex++;
    beginIndex = beginIndex % ARRAY_SIZE;
  }

Afijn, ik ben voor m'n gevoel verder dan vorige week, maar er moet nog wat gebeuren... :-)

Groet, Johan

Als ik in de serial monitor

beginIndex, eindIndex, Array

print, krijg ik dit:

0,1
 19.8   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
0,2
 19.8  19.8   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
0,3
 19.8  19.8  19.8   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
0,4
 19.8  19.8  19.8  19.8   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
0,5
 19.8  19.8  19.8  19.8  19.7   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
0,6
 19.8  19.8  19.8  19.8  19.7  19.8   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
0,7
 19.8  19.8  19.8  19.8  19.7  19.8  19.7   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
0,8
 19.8  19.8  19.8  19.8  19.7  19.8  19.7  19.7   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
0,9
 19.8  19.8  19.8  19.8  19.7  19.8  19.7  19.7  19.8   0.0   0.0   0.0   0.0   0.0   0.0 
0,10
 19.8  19.8  19.8  19.8  19.7  19.8  19.7  19.7  19.8  19.8   0.0   0.0   0.0   0.0   0.0 
0,11
 19.8  19.8  19.8  19.8  19.7  19.8  19.7  19.7  19.8  19.8  19.8   0.0   0.0   0.0   0.0 
0,12
 19.8  19.8  19.8  19.8  19.7  19.8  19.7  19.7  19.8  19.8  19.8  19.8   0.0   0.0   0.0 
0,13
 19.8  19.8  19.8  19.8  19.7  19.8  19.7  19.7  19.8  19.8  19.8  19.8  19.8   0.0   0.0 
0,14
 19.8  19.8  19.8  19.8  19.7  19.8  19.7  19.7  19.8  19.8  19.8  19.8  19.8  19.8   0.0 
1,0
 19.8  19.8  19.8  19.7  19.8  19.7  19.7  19.8  19.8  19.8  19.8  19.8  19.8  19.8  19.8 
2,1
 19.8  19.8  19.7  19.8  19.7  19.7  19.8  19.8  19.8  19.8  19.8  19.8  19.8  19.9  19.8 
3,2
 19.8  19.7  19.8  19.7  19.7  19.8  19.8  19.8  19.8  19.8  19.8  19.8  19.9  19.8  19.8 
4,3
 19.7  19.8  19.7  19.7  19.8  19.8  19.8  19.8  19.8  19.8  19.8  19.9  19.8  19.8  19.8 
5,4
 19.8  19.7  19.7  19.8  19.8  19.8  19.8  19.8  19.8  19.8  19.9  19.8  19.8  19.8  19.7 
6,5
 19.7  19.7  19.8  19.8  19.8  19.8  19.8  19.8  19.8  19.9  19.8  19.8  19.8  19.8  19.8 
7,6
 19.7  19.8  19.8  19.8  19.8  19.8  19.8  19.8  19.9  19.8  19.8  19.8  19.8  19.8  19.7 
8,7
 19.8  19.8  19.8  19.8  19.8  19.8  19.8  19.9  19.8  19.8  19.8  19.8  19.8  19.8  19.7 
9,8
 19.8  19.8  19.8  19.8  19.8  19.8  19.9  19.8  19.8  19.8  19.8  19.8  19.8  19.8  19.8 
10,9
 19.8  19.8  19.8  19.8  19.8  19.9  19.8  19.8  19.8  19.8  19.8  19.8  19.8  19.9  19.8

Hoe hij was, was dat in de array altijd de laatste entries staan. Als je die doorloopt dan krijg je van zelf de oudste waarde op index 0 en de nieuwste op de hoogste index. Stel je hebt 100 metingen gedaan dan kijk ahw via een window naar de laatste waardes. Al het omrekenen gebeurt automatisch. En dat doe ik met modulo %. Google maar eens

O ja, nu zie ik het.

Maar dan gebeurt dat toch eigenlijk één entry te vroeg? Want als er nog één positie over is (dwz op 0.0 staat) gaat hij al 'opschuiven'.

 25.3   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2   0.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3   0.0   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3   0.0   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1   0.0   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2   0.0   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1   0.0   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5   0.0   0.0 
 25.3  25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4   0.0 
 25.5  25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  25.3 
 25.4  25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  25.5 
 25.4  25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  25.4 
 25.4  25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  25.4 
 25.3  25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  25.4 
 25.2  25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  25.3 
 25.3  25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  25.2 
 25.3  25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  20.7  25.3 
 25.1  25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  20.7  20.5  25.3 
 25.2  25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  20.7  20.5  20.4  25.1 
 25.1  24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  20.7  20.5  20.4  20.4  25.2 
 24.5  23.4  22.6  22.0  21.7  21.3  21.2  20.9  20.6  20.7  20.5  20.4  20.4  20.4  25.1

Als er bij regel 14 dus nog één positie open is, zie ik toch die waarde van 23.4 al terug schuiven, terwijl hij nog ééntje verder zou kunnen? In regel 15 verwacht ik eigenlijk vervolgwaarde van 23.4 op index 15. Of heb je die positie juist nodig om de oudste waarde weer op te slaan?

Modulo moet ik nog eens goed bekijken. Ik begrijp dat de uitkomst 'het deel wat na deling overblijft' is. Maar dat kwartje moet nog iets verder vallen.

Ik zal van de week ff kijken of er nog een fout in zit ergens. Zou zomaar kunnen:)

Dit zou wel goed moeten zijn

/*
    Name:       SDArray.ino
    Created:    6-12-2018 08:41:43
    Author:     nico verduin
    Brief:      Eenvoudige manier om met een array  een ringbuffer te maken
*/

// programma constantes
const uint16_t ARRAY_SIZE = 10;        // we gaan een array maken van 10 entries

// globale variabelen
uint16_t beginIndex = 0;               // startpunt van de ring buffer
uint16_t eindIndex    = 0;             // eindpunt van de ring buffer
double   array[ARRAY_SIZE];            // creer onze tabel

/*
 * @name addEntry
 * @param value double die aan de tabel wordt toegevoegd
 * @brief voegt een waarde toe aan de tabel. Als de tabel vol is, wordt de oudste waarde overschreden
 */
void addEntry(double value) {
    static bool loopAround = false;                // nodig voor het afvangen als de tabel nog nooit is gevuld of deels

    // kijk of we een loop around moeten doen
    if (eindIndex == ARRAY_SIZE) {
        loopAround = true;                        // de tabel is vol
    }
    eindIndex = eindIndex % ARRAY_SIZE;           // meest eenvoudige loop around

    // voeg de waarde toe op de laatste plek
    array[eindIndex] = value;

    // verhoog naar nieuwe laatste plek en loop around als we op het einde zitten
    eindIndex++;
    // pas doen als de tabel helemaal vol is
    if (loopAround) {
        beginIndex++;
        beginIndex = beginIndex % ARRAY_SIZE;
    }
}

/*
* @name getEntry
* @param index index in de array waarvan we de waarde willen hebben
* @returns double
* @brief Geeft de waarde terug uit de tabel relatief tov de eerste waarde.
*/
double getEntry(uint16_t index) {

    // reken de index om naar de juiste plek in de array
    uint16_t berekendeIndex = beginIndex + index;

    // modulo nemen en restwaarde gebruiken
    berekendeIndex = berekendeIndex % ARRAY_SIZE;

    // en geef de waarde maar terug
    return array[berekendeIndex];;
}

/*
 * @name printArray
 * @brief  print de tabel uit
 */
void printArray() {

    char floatAsString[6];        // buffer voor float conversie

    for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
        dtostrf(getEntry(i), 5, 1, floatAsString);
        Serial.print(floatAsString);
        Serial.print(" ");
    }
    Serial.println();
}
/*
 * @name setup()
 * @brief Initializes the program
 */
void setup()
{
    // initialiseer Serial
    Serial.begin(115200);

    // initialiseer onze tabel
    for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
        array[i] = 0.0;
    }

    // vul onze tabel met wat random waarden. Laat de laatste 3 waarden nog ff leeg
    for (uint16_t i = 0; i < ARRAY_SIZE; i++) {
        addEntry((double)i);
        // print de array
        printArray();
    }

    // print de array
    printArray();

    // voeg nu 5 nieuwe waardes toe
    for (uint16_t i = 10; i < 15; i++) {
        addEntry((double)i);

        // en print de tabel elke keer opnieuw uit
        printArray();
    }
}

// Add the main program code into the continuous loop() function
void loop()
{
}

Project SD kaart is ten einde :’(. Ik had een oud SD kaartje gebruikt (256Mb). Op enig moment stopte het veranderen van de data op de schijf. Na wat verdieping bleek dat met name die oude kaarten iets van 10.000 W cycles aan kunnen. En als je dan experimenteert met 1.000.000 write cycles wijzigt de data niet meer.
Echter vandaag komt er een module binnen met een 32Kb F-Ram binnen. Die kan 10^14 write cycles aan. behoudt de data voor 151 jaar en is verkrijgbaar als I2C of SPI interface. Eens kijken of dat beter gaat. Ik maak er wel een apart topic van. En inmiddels heb je al IC’s met 1Mb (wel prijzig, rond de 20 euri)
Voor de TS kan dit wel interessant zijn omdat ik sowieso er een aparte library maak.

Zul je net zien dat ie er met het 150e jaar mee ophoudt...