data updaten op schermen in nextion

algemene C code
Berichten: 55
Geregistreerd: 17 Mrt 2016, 17:05
Woonplaats: Julianadorp

data updaten op schermen in nextion

Berichtdoor Creator » 01 Sep 2019, 17:56

Vervolg op eerdere discussie "Callback functie nextion gebruiken in arduino"

Nadat dit punt is opgelost ben ik verder gegaan met het door ontwikkelen van het Nextion scherm en bijbehorende code.
Waar ben ik nu:
Ik heb een Nextion basic 3,2" scherm, hierop zijn 5 pagina's

Page0 = beginscherm (hierop staat de Datum in de format "weekdag", "DD - MM - JJJJ" en de Tijd in "UU:MM:SS". Ook zijn
hier 2 PushButtons voor navigatie binnen de nextion schermen en een Slider welke de helderheid van
het display insteld. It is een interne code binnen de nextion>)

Page1= hoofdscherm (hierop wordt de tijd gepresenteerd welke de timer telt gedurende de tijd tussen "start en stop".
3 tijd notatie's, ODO tijd format "UU:MM:SS" , Sessie tijd format "UU:MM" en Tijd tot onderhoud wat
een countdown is in de format "UU:MM". De ODO en Onderhoud tijden worden weggeschreven naar
de eeprom.
Ook hier 2 PushButtons 1 voor navigatie binnen de schermen, 1 voor het wegschrijven naar de
eeprom "save" en 1 DualStateButton voor de Start en Stop functie.

Page2= instellingen (een menu scherm voor navigatie naar de optie's voor aanpassen Datum en Tijd, en veranderen van
de tijd "uren" tot onderhoud. Totaal 5 PushButtons voor interne navigatie.)

Page3= set datum

Page4= set tijd

Page5= onderhoud (hierop worden de uren tot onderhoud ingesteld tot een maximum van 99, opgeslagen waarde wordt
opgehaald uit eeprom en gepresenteerd in een numeriek veld. 6 PushButtons, een + en - button voor
de uren code in arduino, "save" button voor opslaan op eeprom, "reset" button voor instellen van
(default waarde 20) uren, 2 navigatie buttons voor schermen binnen de nextion.)

Wat heb ik werkend:
- Page0 (beginscherm) de RTC klok met de datum en tijd weergave op het scherm,
- Page5 (onderhoud)

Deels werkend:
- Page1 (hoofdscherm) de tijden worden opgehaald uit de eeprom, echter de tijden worden niet geupdate dor de timer
er is geen communicatie naar scherm 1. Of de ophaallus blijft hangen en wordt er iedere seconde
gekeken op de eeprom en de oude tijd gepresenteerd?

Nog niet werkend:
- Page3 en 4 maar dat is de volgende stap


De Arduino code heb ik geschreven met gebruik van de tabbladen dus de hoofdsketch met paragrafen page 1, page 5, en rtcTjd.
bijgevoegd de hoofd sketch en de page 1 waar het fout bij gaat



Code: Alles selecteren
/** *************************************************************************************
      Copyright :  EFCreations
      Autheur   :  Erik
      Datum     :  August 2019 (Eerste versie 1.0)
      Programma :  Bedrijfstijden teller voor vast opgestelde machines
      Beschrijving  : Bedrijfstijd wordt bijgehouden t.b.v. vast opgestelde
                      machines. Op display info over: Huidige datum en tijd,
                      ODO tijd, tijd huidige sessie, Ingestelde tijd tot volgend
                      onderhoud, Dimbaar scherm d.m.v. schuifregelaar.
      Revisie   :
 *                                                                                     *
 **************************************************************************************/

/* *************************************************************************************
   Sketch t.b.v.
   - het weergeven van de datum en tijd uit de DS3231;
   - het starten en stoppen/pauzeren van de odo en sessie timer;
   - het starten van de countdown timer voor tijd tot onderhoud;
   - het wegschrijven en ophalen van de ingestelde tijd tot onderhoud;
   - het wegschrijven en ophalen van de odo tijd;
   - het aanpassen van de RTC klok (datum & tijd).
   Gebruikte hardware:
    - Arduino MEGA 2560 communiceerd op Serial2
    - Nextion Basic 3,2 inch display
    - DS3231 RTC SDA-pin 20, SCL-pin 21
 **************************************************************************************/

#include <Nextion.h>        // Bibliotheek voor HMI display
#include <EEPROM.h>         // Bibliotheek voor gebruik van EEPROM
#include <RTClib.h>         // Bibliotheek voor DS3231 Real Time Clock


//*************declareer de globale constante*******************************************
boolean start = false;
RTC_DS3231 rtc;

// EEPROM adressen voor odo tijdtelling countup teller*****************************************************
const uint8_t EEPROM_ODO_UREN      = 0;    // odo uren op byte 0 en 1
const uint8_t EEPROM_ODO_MINUTEN   = 2;    // odo minuten op byte 2
const uint8_t EEPROM_ODO_SECONDEN  = 3;    // odo minuten op byte 2

// EEPROM adressen voor onderhoud countdown teller*********************************************************
const uint8_t EEPROM_MNT_SETTIME   = 4;    // schrijf ingestelde tijd weg op byte 3
const uint8_t EEPROM_MNT_UREN      = 5;    // resterende uren tot onderhoud op adres 4
const uint8_t EEPROM_MNT_MINUTEN   = 6;    // resterende minuten tot onderhoud  op adres 5

//*************setup variabelen voor odo tijd telling *****************************************************
uint32_t timer;                 // de timer wordt voor alle gebruikt

//*********************sectie odo tijd \telling countup****************************************************
uint16_t odoHour = 0;           // opgelopen tijd uren 3 digit display
uint8_t odoMinute = 0;          // minuten 2 digit display
uint8_t odoSecond = 0;          // seconden 2 digit display, worden genegeerd bij save
//*********************sectie sessie tijdtelling countup***************************************************
uint8_t sesHour  = 0;           // tijd wordt niet weggeschreven naar EEPROM
uint8_t sesMinute = 0;          // enkel op display weergegeven tot afsluiten prog.
uint8_t sesSecond = 0;          //
//*********************sectie onderhoud countdown**********************************************************
uint8_t mntSet  = 0;            // ingestelde uren tot onderhoud
uint8_t mntHour  = 0;           // tijd wordt weggeschreven en opgehaald bij start/stop
uint8_t mntMinute = 0;          // resterende tijd tot onderhoud in uren en odoMinuten
uint8_t mntSecond = 0;          // worden genegeerd bij save en display

unsigned long vorigeMillis = 0; // resetten van de teller
const long interval = 1000;     // de 1 sec vertraging voor de teller

char buffer[20] = {0};            // tijdelijk tekst opslaan tbv string functie
//************************mogelijkheid tot tekst in datum voor weekdag en maand****************************
const char* weekdag[] = {"Zondag", "Maandag", "Dinsdag", "Woensdag", "Donderdag", "Vrijdag", "Zaterdag"};
const char* maand[] = {"Jan", "Feb", "Mrt", "Apr", "Mei", "Jun", "Jul", "Aug", "Sep", "Nov", "Dec"};

//**********************setup van nextion buttons *********************************************************
NexDSButton btstart = NexDSButton(0, 2, "btstart");   // start-stop timer
NexButton bsave = NexButton(0, 6, "bsave");           // opslaan naar eeprom
NexButton bHplus = NexButton(5, 3, "bHplus");           // onderhoud uren +
NexButton bHmin = NexButton(5, 4, "bHmin");             // onderhoud uren -
NexButton bmsave = NexButton(5, 2, "bmsave");           // opslaan naar eeprom
NexButton bmreset = NexButton(5, 6, "bmreset");        // default op 20 uur

NexPage page1 = NexPage(1, 0, "page1");               // Bedrijfsuren (hoofdscherm)
NexPage page5 = NexPage(5, 0, "page5");               // Instellen uren tot onderhoud

//***********************defineer lees lijst nextion buttons **********************************************
NexTouch *nex_listen_list[] =
{
  &btstart,  &bsave,                      //op pagina 0
  &bHplus,  &bHmin, &bmsave,  &bmreset,   //op pagina 5
  &page1, &page5,
  NULL
};


//***********************defineer buttons als void pointers ***********************************************
void btstartPushCallback (void *ptr)    // Dual state button voor start ^stop functie
{
  uint32_t number5 = 0;                 // maak variable om waarde op te slaan
  btstart.getValue(&number5);           // Lees de waarde dual state button, state (0 or 1)
  if (number5 == 1)                     // als dual state button is gelijk aan 1 dan....
  {
    start = true;                       // uit te voeren opdracht begin met tellen
  } else
  {
    start = false;                      // uit te voeren opdracht stop met tellen
  }
}
//************************Instellen uren tot onderhoud*****************************************************
void bHplusPushCallback(void *ptr)      // 1 uur erbij tot max. 99
{
  if (mntSet >= 0 && mntSet <= 99);
  {
    mntSet = mntSet + 1;
    Serial2.print("nuur.val=");
    Serial2.print(mntSet);
    Serial2.write(0xff);
    Serial2.write(0xff);
    Serial2.write(0xff);
  }
}

void bHminPushCallback(void *ptr)       // 1 uur eraf tot minimaal 1 (minder dan 1 uur kan niet)
{
  if (mntSet >= 1 && mntSet <= 99);
  {
    mntSet = mntSet - 1;
    Serial2.print("nuur.val=");
    Serial2.print(mntSet);
    Serial2.write(0xff);
    Serial2.write(0xff);
    Serial2.write(0xff);
  }
}

/*************************save ingestelde uren tot onderhoud***********************************************
  Bewaar de de uren op eeprom, noodzakenlijk omdat anders de waarde niet wordt gebruikt
  D.m.v. Reset wordt een default waarde van 20 uur ingesteld.
**********************************************************************************************************/
void bmsavePushCallback(void *ptr)                // bewaar de aangepaste tijd voor onderhoud
{
  EEPROM.write(EEPROM_MNT_SETTIME, mntSet);       // wordt bewaard voor gebruik op page 5
  mntHour = mntSet;
  EEPROM.write(EEPROM_MNT_UREN , mntHour);        // wordt bewaard voor gebruik op page 1
  EEPROM.write(EEPROM_MNT_MINUTEN , mntMinute);   // wordt bewaard voor gebruik op page 1

  Serial2.print("nuur.val=");                     // id .. (in nextion editor)
  Serial2.print(mntSet);
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);
}

//************************reset ingestelde uren naar default 24 uur****************************************
void bmresetPushCallback(void *ptr)               // reset uren tot onderhoud default 20uur
{
  mntSet = 20;                                    // ingestelde default waaarde
  mntHour = mntSet;
  EEPROM.write(EEPROM_MNT_SETTIME, mntSet);       // bewaar default uren tot onderhoud
  // display aantal ingestelde uren tot onderhoud
  Serial2.print("nuur.val=");                     // show de tijd op display
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);
}

//************************bewaar ODO en resterende tijd tot onderhoud**************************************
void bsavePushCallback(void *ptr)                 // bewaar odo tijd
{
  EEPROM.write(EEPROM_ODO_UREN , odoHour / 256);        // high byte
  EEPROM.write(EEPROM_ODO_UREN + 1  , odoHour % 256);   // low byte
  EEPROM.write(EEPROM_ODO_MINUTEN , odoMinute);
  EEPROM.write(EEPROM_ODO_SECONDEN , odoSecond);

  //**********************bewaar de resterende tijd tot onderhouds*****************************************
  EEPROM.write(EEPROM_MNT_UREN , mntHour);        // wordt bewaard voor gebruik op page 1
  EEPROM.write(EEPROM_MNT_MINUTEN , mntMinute);   // wordt bewaard voor gebruik op page 1
}


//*************************************Setup programma*****************************************************
void setup()
{
  start = false;            // Timer staat initieel uit/stop
  nexInit();                // Start communicatie met Nextion display
  rtc.begin();              // Start communicatie met RTC

  //***************************Callback functie initieren**************************************************
  btstart.attachPush(btstartPushCallback);
  bHplus.attachPush(bHplusPushCallback, &bHplus);
  bHmin.attachPush(bHminPushCallback, &bHmin);
  bmreset.attachPush(bmresetPushCallback, &bmreset);
  bmsave.attachPush(bmsavePushCallback, &bmsave);

  page1.attachPush(page1PushCallback);
  page5.attachPush(page5PushCallback);
}


//************************************Main programma*******************************************************
void loop()
{
  nexLoop(nex_listen_list);   // luister naar de buttons uit de luister lijst

  unsigned long huidigeMillis = millis(); // de daadwerkelijke teller
  if (huidigeMillis - vorigeMillis >= interval)
  {
    vorigeMillis = huidigeMillis; // terug naar 0 en opnieuw beginnen, delay was 1 sec
    rtcTijd();                    // tabblad trcTijd display weekdag DD-MM-JJJJ op page 0

    if (start == true)
    {
     
      odoTijd();
      //sessieTijd();
    }
    else
    {
      timer = 0;
      // stimer = 0;
      start = false;
    }
  }
}

//******************Sub programma voor odo klok timer *****************************************************
void odoTijd()                       // countup teller op page 1
{
  timer = millis();
  odoSecond++;                       // seconde verlopen
  if (odoSecond == 60)
  {
    odoMinute++;                     // minuut verlopen?
    odoSecond = 0;
  }
  if (odoMinute == 60)
  {
    odoHour++;                       // uur verlopen?
    odoMinute = 0;
  }
  //*********************display de tijd op nextion display  op page 1*************************************
  char oTime[11];
  sprintf(oTime, "%03d:%02d:%02d", odoHour, odoMinute, odoSecond);
  page1,Serial2.print(F("todo.txt=\""));
  page1,Serial2.print(oTime);
  page1,Serial2.print("\"");
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);
}

//******************Sub programma voor sessie timer *******************************************************
void sessieTijd()                 // countup teller op page 1
{
  timer = millis();
  sesSecond++;                       // seconde verlopen
  if (sesSecond == 60)
  {
    sesMinute++;                     // minuut verlopen?
    sesSecond = 0;
  }
  if (sesMinute == 60)
  {
    sesHour++;                       // uur verlopen?
    sesMinute = 0;
  }
  //*********************display de tijd op nextion display ***********************************************
  char sTime[10];
  sprintf(sTime, "%02d:%02d:%02d", sesHour, sesMinute, sesSecond);
  Serial2.print(F("tsessie.txt=\""));  //nog aan te maken
  Serial2.print(sTime);
  Serial2.print("\"");
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);
}

//******************Sub programma voor onderhoud timer ****************************************************
void maintTijd()        // countdown teller op page 1
{
  if (mntSecond > 0)
  {
    mntSecond -= 1;
  }
  else if (mntMinute > 0)
  {
    mntSecond = 59;
    mntMinute -= 1;
  }
  else if (mntHour > 0)
  {
    mntSecond = 59;
    mntMinute = 59;
    mntHour -= 1;
  }
  //*********************display de tijd op nextion display ***********************************************
  char mTime[6];
  sprintf(mTime, "%02d:%02d", mntHour, mntMinute);
  Serial2.print(F("tmaint.txt=\""));
  Serial2.print(mTime);
  Serial2.print("\"");
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);
}


Het gedeelte waar het om gaat de eeprom wordt gelezen en daarna houdt het op!  :roll:

 
Zolang dit scherm actief is en dat is meestal gebeurd er niets anders dan kijken naar dde eeprom. Hoe maak ik nu een verwijzing
naar de main loop om de timer data door te geven naar de velden op page1?
Waar ga ik fout?

Code: Alles selecteren

void page1PushCallback(void *ptr)
{
  dbSerialPrintln("page1PushCallback");
  page1.show();

  //*****************ophalen bewaarde resterende tijd tot Onderhoud*****************************************
  mntHour    = EEPROM.read(EEPROM_MNT_UREN);
  mntMinute  = EEPROM.read(EEPROM_MNT_MINUTEN);

  char mntTime[6];
  sprintf(mntTime, "%02d:%02d", mntHour, mntMinute);
  Serial2.print(F("tmaint.txt=\""));
  Serial2.print(mntTime);
  Serial2.print("\"");
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);

  //******************Display ODO tijd op display 000:00:00*************************************************
  odoHour    = (EEPROM.read(EEPROM_ODO_UREN) * 256) + EEPROM.read(EEPROM_ODO_UREN + 1);
  odoMinute  = EEPROM.read(EEPROM_ODO_MINUTEN);
  odoSecond  = EEPROM.read(EEPROM_ODO_SECONDEN);

  char oTime[11];
  sprintf(oTime, "%03d:%02d:%02d", odoHour, odoMinute, odoSecond);
  Serial2.print(F("todo.txt=\""));
  Serial2.print(oTime);
  Serial2.print("\"");
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);

  //******************Display Sessie tijd op display 00:00:00***********************************************
  char sTime[10];
  sprintf(sTime, "%02d:%02d:%02d", sesHour, sesMinute, sesSecond);
  Serial2.print(F("tsessie.txt=\"")); 
  Serial2.print(sTime);
  Serial2.print("\"");
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);
}

Advertisement

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

Re: data updaten op schermen in nextion

Berichtdoor Koepel » 02 Sep 2019, 16:07

Een goede vraag, maar ik ben er zelf ook nog niet helemaal uit :(
Ik heb nog maar één klein project met een Nextion display gedaan, en ik gebruik de ITEAD library niet meer. Ik doe alles gewoon met de seriële commando's van en naar het display.

Misschien helpt het als ik vertel hoe ik het heb gedaan:
Ik geef de voorkeur er aan om zoveel mogelijk in de Arduino te doen en zo weinig mogelijk in het display.
Elke pagina van het scherm heeft een eigen tabblad in de Arduino IDE.
Een tabblad van een pagina heeft een "begin" functie en een "update" functie, en ik heb een variabele 'NextionPage' die aangeeft welke pagina aktief is.
Als ik naar een andere pagina ga, dan hou ik in de code die variabele 'NextionPage' netjes bij.
De "begin" functie zet de dingen goed op het scherm en vult tekst in en zo.
De "update" functie is om bijvoorbeeld een klok te laten zien.
In de Arduino loop() kijk ik naar 'NextionPage' en dan roep ik de update functie van die pagina aan.
Als er op het scherm op een knop is gedrukt, dan zit daar de informatie van de pagina bij. En ik heb mijn variabele 'NextionPage', dus ik weet dan bij welke pagina het hoort.

Ik update dus alleen maar een pagina die op het scherm staat. Ik heb wel eens een proef gedaan om te kijken of ik iets van een andere pagina kon updaten, maar ik ben vergeten hoe dat ging :oops:

Wat wil je met de komma achter "page1" bereiken ?
Code: Alles selecteren
page1,Serial2.print(F("todo.txt=\""));
De "page1" is het Nextion object van een pagina.

Berichten: 55
Geregistreerd: 17 Mrt 2016, 17:05
Woonplaats: Julianadorp

Re: data updaten op schermen in nextion

Berichtdoor Creator » 02 Sep 2019, 17:18

Hallo koepel,

Bedankt voor je reactie, Ik ga je voorbeeld volgen om iedere pagina een eigen tabblad te geven, om op die manier het overzicht te behouden.

De Nextion library zal ik wel blijven gebruiken denk ik, en nu maak ik alleen gebruik van de nextion editor om intern binnen de schermen te navigeren.
Bij de preinitialize events van een pagina plaats ik deze code " printh 65 00 00 01 FF FF FF " waarbij de eerste 2 nullen de pagina id aangeven dus 00 voor page 0 en 01 page 1, enz .
en die wordt als PushButton gelezen en in de arduino code gebracht. Dus bij veranderen van pagina stuurt het display automatisch zijn pagina nr. door.
dus jou variable NextionPage kan ik dan mooi gebruiken voor het bijhouden van de actieve pagina.

De opbouw klinkt heel logisch en die ga ook proberen toe te passen, de begin Functie gaat me wel lukken alleen de update functie daar zal ik nog wel wat moeite mee krijgen.


page1,Serial2.print(F("todo.txt=\""));

deze 3 coderegels zijn nog een foutje die ik vergeten ben op te schonen, mea culpa. Was een probeersel om de page actief te maken en de betreffende text daar te laten verschijnen.

Berichten: 55
Geregistreerd: 17 Mrt 2016, 17:05
Woonplaats: Julianadorp

Re: data updaten op schermen in nextion

Berichtdoor Creator » 03 Sep 2019, 19:53

Weer een stukje verder in de puzzel die programmeren wordt genoemd ;)

Ik heb het volgende werkend:
Op de openingspagina wordt de RTC datum en tijd weergegeven format "weekdag" DD - "maand" - JJJJ en de tijd in UU:MM:SS
Op de urenteller pagina wordt de tijd op en afgeteld, ODO en Sessietijd opgeteld en uren tot onderhoud afgeteld.
Op de instel pagina #uren tot onderhoud worden de uren met 1 bij of afgeteld en weergegeven op de vorige pagina.

Nu het volgende
Wegschrijven naar de EEPROM, hier gaat het nog niet soepel, volgens mij zit er geen fout in de code maar toch lees ik niet de waarden die zouden moeten zijn weggeschreven?
Zijn de adressen wel valide die ik gebruik?

Hier een deel van de totale sketch betreffende het eeprom gedeelte

Code: Alles selecteren
#include <EEPROM.h>         // Bibliotheek voor gebruik van EEPROM
// EEPROM adressen voor odo tijdtelling countup teller
const uint16_t EEPROM_ODO_UREN     = 0;    // odo uren op byte 0 en 1
const uint8_t EEPROM_ODO_MINUTEN   = 2;    // odo minuten op byte 2
const uint8_t EEPROM_ODO_SECONDEN  = 3;    // odo minuten op byte 2

// EEPROM adressen voor onderhoud countdown teller
const uint8_t EEPROM_MNT_SETTIME   = 4;    // schrijf ingestelde tijd weg op byte 3
const uint8_t EEPROM_MNT_UREN      = 5;    // resterende uren tot onderhoud op adres 4
const uint8_t EEPROM_MNT_MINUTEN   = 6;    // resterende minuten tot onderhoud  op adres 5


void bmsavePushCallback(void *ptr)                // bewaar de aangepaste tijd voor onderhoud
{
  EEPROM.write(EEPROM_MNT_SETTIME, mntSet);       // wordt bewaard voor gebruik op page 5
  mntHour = mntSet;
  EEPROM.write(EEPROM_MNT_UREN , mntHour);        // wordt bewaard voor gebruik op page 1
  EEPROM.write(EEPROM_MNT_MINUTEN , mntMinute);   // wordt bewaard voor gebruik op page 1
 [color=#80BF00] // display aantal ingestelde uren tot onderhoud[/color]
  Serial2.print("nuur.val=");                     // id .. (in nextion editor)
  Serial2.print(mntSet);
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);
}


void bsavePushCallback(void *ptr)                 // bewaar odo tijd
{
  EEPROM.write(EEPROM_ODO_UREN , odoHour / 256);        // high byte
  EEPROM.write(EEPROM_ODO_UREN + 1  , odoHour % 256);   // low byte
  EEPROM.write(EEPROM_ODO_MINUTEN , odoMinute);
  EEPROM.write(EEPROM_ODO_SECONDEN , odoSecond);

  //**********************bewaar de resterende tijd tot onderhoud
  EEPROM.write(EEPROM_MNT_UREN , mntHour);        // wordt bewaard voor gebruik op page 1
  EEPROM.write(EEPROM_MNT_MINUTEN , mntMinute);   // wordt bewaard voor gebruik op page 1
}

void leesTijd()
{
//*****************ophalen bewaarde resterende tijd tot Onderhoud
  mntHour    = EEPROM.read(EEPROM_MNT_UREN);
  mntMinute  = EEPROM.read(EEPROM_MNT_MINUTEN);
   
  char mntTime[6];
  sprintf(mntTime, "%02d:%02d", mntHour, mntMinute);
  Serial2.print(F("tmaint.txt=\""));
  Serial2.print(mntTime);
  Serial2.print("\"");
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);
 
  //******************Display ODO tijd op display 000:00:00***********************
  odoHour    = (EEPROM.read(EEPROM_ODO_UREN) * 256) + EEPROM.read(EEPROM_ODO_UREN + 1);
  odoMinute  = EEPROM.read(EEPROM_ODO_MINUTEN);
  odoSecond  = EEPROM.read(EEPROM_ODO_SECONDEN);

  char oTime[11];
  sprintf(oTime, "%03d:%02d:%02d", odoHour, odoMinute, odoSecond);
  Serial2.print(F("todo.txt=\""));
  Serial2.print(oTime);
  Serial2.print("\"");
  Serial2.write(0xff);
  Serial2.write(0xff);
  Serial2.write(0xff);
}


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

Re: data updaten op schermen in nextion

Berichtdoor Koepel » 04 Sep 2019, 19:12

Ik zie geen probleem met het EEPROM.
Zit er logica in de waarden die je terug krijgt ? Zijn alle waarden verkeerd ?

Je mag het EEPROM gebruiken zoals je wilt. De EEPROM.read() leest een byte en EEPROM.write() schrijft een byte. Dus je kan niet iets anders lezen dan wat je hebt weggeschreven.

Kun je een proef doen, bijvoorbeeld in setup(), om de EEPROM te schrijven en te lezen ?

Je gebruikt de NexLoop() van de ITEAD library en je schrijft ook zelf commando's naar het scherm. Als de ITEAD library een commando schrijft, dan wordt er ook gewacht op een bevestiging van het display. Dat doe jij niet, dus die bevestiging komt aan bij NexLoop(), en die mag dat op ruimen. Ik weet niet of dat goed gaat.

Ik krijg de kriebels van precies uitgetelde buffers. Een %02d is een minimum breedte: http://www.cplusplus.com/reference/cstdio/printf/. Dus stel dat er 255 gelezen wordt vanuit het EEPROM, dan geeft %02d toch "255" als resultaat. Misschien wordt er -127 gelezen als het een 'char' is, dat is nóg een extra karakter er bij (het minus teken). Dan ben je andere geheugen plekken aan het overschrijven en kan er van alles gebeuren. Je kunt er beter voor zorgen dat als er een probleem is, dat het dan niet door je hele sketch heen dendert.

Ik gebruik vaak één algemene globale buffer.
Dit is een mogelijkheid:
Code: Alles selecteren
char buffer[80];
sprintf( buffer, "tmaint.txt=\"%02d:%02d\"\xFF\xFF\xFF", mntHour, mntMinute);
Serial2.write( buffer);


Maar dat is niet voldoende, want de ITEAD library doet iets anders.
Neem als voorbeeld een text sturen.
De setText() roept eerst sendCommand() aan, die eerst de seriele buffer leeghaalt, daarna wordt de tekst verstuurd.
De setText() roept daarna recvRetCommandFinished() aan, die met een timeout de reactie van het display leest.

De setText(): https://github.com/itead/ITEADLIB_Arduino_Nextion/blob/master/NexText.cpp#L32
De sendCommand(): https://github.com/itead/ITEADLIB_Arduino_Nextion/blob/master/NexUpload.cpp#L122
De recvRetCommandFinished(): https://github.com/itead/ITEADLIB_Arduino_Nextion/blob/master/NexHardware.cpp#L187

Berichten: 55
Geregistreerd: 17 Mrt 2016, 17:05
Woonplaats: Julianadorp

Re: data updaten op schermen in nextion

Berichtdoor Creator » 04 Sep 2019, 20:27

Probleem opgelost :D
Eigenlijk helemaal geen probleem maar een programmer error :oops:
De betreffende Callback functie had een schrijffout in de loo(). :ugeek:

Wat werkt er nu;
Beginscherm - toont rtc datum en tijd en werkt deze bij ook na schakelen tussen de schermen
Hoofdscherm - de 3 timers werken en waarden worden weggeschreven en ook weer uit gelezen
Uren tot onderhoud - tjid word weggeschreven en opgehaald en bijgewerkt op hoofdscherm

Ik zou wat schermopname willen plaatsen maar krijg dit niet voor elkaar? :cry:


De code is nu als volgt opgebouwd;
- de hoofdsketch
- tabblad Timers (hier staan de functies voor de drie timers)
- tabblad RTC (de benodige data voor de ds3231)
- tabblad leesTijd (ophalen tijden uit eeprom)

De hoofdsketch

ccp code
#include <Nextion.h>        // Bibliotheek voor HMI display
#include <EEPROM.h> // Bibliotheek voor gebruik van EEPROM
#include <RTClib.h> // Bibliotheek voor DS3231 Real Time Clock

RTC_DS3231 rtc;
//************************mogelijkheid tot tekst in datum voor weekdag en maand****************************
const char* weekdag[] = {"Zondag","Maandag","Dinsdag","Woensdag","Donderdag","Vrijdag","Zaterdag"};
const char* maand[] = {"Fout","Jan","Feb","Mrt","Apr","Mei","Jun","Jul","Aug","Sep","Okt","Nov","Dec"};

boolean start = false;

char buffer[100] = {0}; // tijdelijk tekst opslaan tbv string functie

// EEPROM adressen voor odo tijdtelling *******************************************************************
const uint16_t EEPROM_ODO_UREN = 0; // odo uren op byte 0 en 1
const uint8_t EEPROM_ODO_MINUTEN = 2; // odo minuten op byte 2
const uint8_t EEPROM_ODO_SECONDEN = 3; // odo minuten op byte 2

// EEPROM adres voor uren tot onderhoud *******************************************************************
const uint8_t EEPROM_MNT_SETTIME = 4; // schrijf ingestelde tijd weg op byte 3

// EEPROM adressen voor restrende tijd tot onderhoud ******************************************************
const uint8_t EEPROM_MNT_UREN = 5; // resterende uren tot onderhoud op adres 4
const uint8_t EEPROM_MNT_MINUTEN = 6; // resterende minuten tot onderhoud op adres 5

//*************setup variabelen voor odo tijd telling *****************************************************
uint32_t timer; // de timer wordt voor alle gebruikt
unsigned long vorigeMillis = 0; // resetten van de teller
const long interval = 1000; // de 1 sec vertraging voor de teller

//*********************sectie odo tijd \telling countup****************************************************
uint16_t odoHour = 0; // opgelopen tijd uren 3 digit display
uint8_t odoMinute = 0; // minuten 2 digit display
uint8_t odoSecond = 0; // seconden 2 digit display, worden genegeerd bij save
//*********************sectie sessie tijdtelling countup***************************************************
uint8_t sesHour = 0; // tijd wordt niet weggeschreven naar EEPROM
uint8_t sesMinute = 0; // enkel op display weergegeven tot afsluiten prog.
uint8_t sesSecond = 0; //
//*********************sectie onderhoud countdown**********************************************************
uint8_t mntSet = 0; // ingestelde uren tot onderhoud
uint8_t mntHour = 0; // tijd wordt weggeschreven en opgehaald bij start/stop
uint8_t mntMinute = 0; // resterende tijd tot onderhoud in uren en odoMinuten
uint8_t mntSecond = 0; // worden genegeerd bij save en display

//**********************setup van nextion buttons *********************************************************
NexDSButton btstart = NexDSButton(1, 2, "btstart"); // start-stop timer
NexButton bsave = NexButton(1, 6, "bsave"); // opslaan naar eeprom
NexButton bHplus = NexButton(5, 3, "bHplus"); // onderhoud uren +
NexButton bHmin = NexButton(5, 4, "bHmin"); // onderhoud uren -
NexButton bmsave = NexButton(5, 2, "bmsave"); // opslaan naar eeprom
NexButton bmreset = NexButton(5, 6, "bmreset"); // default op 20 uur

NexPage page1 = NexPage(1, 0, "page1"); // Bedrijfsuren (hoofdscherm)
NexPage page5 = NexPage(5, 0, "page5"); // Instellen uren tot onderhoud

//***********************defineer lees lijst nextion buttons **********************************************
NexTouch *nex_listen_list[] =
{
&btstart, &bsave, //op pagina 1
&bHplus, &bHmin, &bmsave, &bmreset, //op pagina 5
&page1, &page5,
NULL
};

//***********************defineer buttons als void pointers ***********************************************
void btstartPushCallback (void *ptr) // Dual state button voor start ^stop functie
{
uint32_t number5 = 0; // maak variable om waarde op te slaan
btstart.getValue(&number5); // Lees de waarde dual state button, state (0 or 1)
if (number5 == 1) // als dual state button is gelijk aan 1 dan....
{
start = true; // uit te voeren opdracht begin met tellen
} else
{
start = false; // uit te voeren opdracht stop met tellen
sesHour = 0; // reset sessietijd
sesMinute = 0;
sesSecond = 0;
}
}

//************************bewaar ODO en resterende tijd tot onderhoud**************************************
void bsavePushCallback(void *ptr) // bewaar odo tijd
{
EEPROM.write(EEPROM_ODO_UREN , odoHour / 256); // high byte
EEPROM.write(EEPROM_ODO_UREN + 1 , odoHour % 256); // low byte
EEPROM.write(EEPROM_ODO_MINUTEN , odoMinute);
EEPROM.write(EEPROM_ODO_SECONDEN , odoSecond);

//**********************bewaar de resterende tijd tot onderhoud *****************************************
EEPROM.write(EEPROM_MNT_UREN , mntHour); // wordt bewaard voor gebruik op page 1
EEPROM.write(EEPROM_MNT_MINUTEN , mntMinute); // wordt bewaard voor gebruik op page 1
}


//************************Instellen uren tot onderhoud*****************************************************
void bHplusPushCallback(void *ptr) // 1 uur erbij tot max. 99
{
if (mntSet >= 0 && mntSet <= 99);
{
mntSet = mntSet + 1;
Serial2.print("nuur.val=");
Serial2.print(mntSet);
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);
}
}

void bHminPushCallback(void *ptr) // 1 uur eraf tot minimaal 1 (minder dan 1 uur kan niet)
{
if (mntSet >= 1 && mntSet <= 99);
{
mntSet = mntSet - 1;
Serial2.print("nuur.val=");
Serial2.print(mntSet);
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);
}
}

//************************save ingestelde uren tot onderhoud***********************************************
// Bewaar de de uren op eeprom, noodzakenlijk omdat anders de waarde niet kan worden gebruikt
void bmsavePushCallback(void *ptr) // bewaar de aangepaste tijd voor onderhoud
{
EEPROM.write(EEPROM_MNT_SETTIME, mntSet); // wordt bewaard voor gebruik op page 5
mntHour = mntSet; // neem de waarde over voor tijdtelling
EEPROM.write(EEPROM_MNT_UREN , mntHour); // wordt bewaard voor gebruik op page 1
EEPROM.write(EEPROM_MNT_MINUTEN , mntMinute); // wordt bewaard voor gebruik op page 1

Serial2.print("nuur.val="); // display aantal ingestelde uren tot onderhoud
Serial2.print(mntSet);
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);
}

//************************reset ingestelde uren naar default 24 uur****************************************
void bmresetPushCallback(void *ptr) // reset uren tot onderhoud default 20uur
{
mntSet = 20; // ingestelde default waaarde
EEPROM.write(EEPROM_MNT_SETTIME, mntSet); // bewaar default uren tot onderhoud
mntHour = mntSet; // neem de waarde over voor tijdtelling
EEPROM.write(EEPROM_MNT_UREN , mntHour); // wordt bewaard voor gebruik op page 1
EEPROM.write(EEPROM_MNT_MINUTEN , mntMinute); // wordt bewaard voor gebruik op page 1

Serial2.print("nuur.val="); // display aantal ingestelde uren tot onderhoud
Serial2.print(mntSet);
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);
}



//******************************ophalen timer tijden*******************************************************
void page1PushCallback(void *ptr)
{
leesTijd(); // ophalen bewaarde tijden uit eeprom
}

//************************ophalen ingeselde tijd tot onderhoud*********************************************
void page5PushCallback(void *ptr)
{
mntSet = EEPROM.read(EEPROM_MNT_SETTIME);

Serial2.print("nuur.val=");
Serial2.print(mntSet);
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);
}

void setup() //*****************************Setup van programma *******************************************
{
start = false; // Timer staat initieel uit/stop
nexInit(); // Start communicatie met Nextion display
rtc.begin();
//***************************Callback functie initieren**************************************************
btstart.attachPush(btstartPushCallback);
bsave.attachPush(bsavePushCallback, &bsave);
bHplus.attachPush(bHplusPushCallback, &bHplus);
bHmin.attachPush(bHminPushCallback, &bHmin);
bmreset.attachPush(bmresetPushCallback, &bmreset);
bmsave.attachPush(bmsavePushCallback, &bmsave);

page1.attachPush(page1PushCallback);
page5.attachPush(page5PushCallback);
}


void loop() //*****************************Hoofd programma ***********************************************
{
nexLoop(nex_listen_list); // luister naar de buttons uit de luister lijst
rtcTijd();

unsigned long huidigeMillis = millis(); // de daadwerkelijke teller
if (huidigeMillis - vorigeMillis >= interval)
{
vorigeMillis = huidigeMillis; // terug naar 0 en opnieuw beginnen, delay was 1 sec
if (start == true)
{
odoTijd(), sessieTijd(), maintTijd();
}
else
{
timer = 0;
start = false;
}
}
}


de rtc code

[/code2=ccp]
void rtcTijd() //*******************RTC datum en tijd display op page 0***********************************
{
DateTime now = rtc.now(); // gebruik de actuele tijd van dertc

char datum[12];
sprintf(datum, "%2d-%s-%04d", now.day(), maand[now.month()], now.year());
Serial2.print(F("tdatum.txt=\""));
Serial2.print(datum);
Serial2.print("\"");
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);

char dag[12];
sprintf(dag, "%s ", weekdag[now.dayOfTheWeek()]);
Serial2.print(F("tdag.txt=\""));
Serial2.print(dag);
Serial2.print("\"");
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);

char tijd[9];
sprintf(tijd, "%02d:%02d:%02d", now.hour(), now.minute(), now.second());
Serial2.print(F("ttijd.txt=\""));
Serial2.print(tijd);
Serial2.print("\"");
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);
}
[/code2]

de timers

[/code2=ccp]
//******************Sub programma voor odo klok timer ********************************
void odoTijd() // countup teller op page 1
{
timer = millis();
odoSecond++; // seconde verlopen
if (odoSecond == 60)
{
odoMinute++; // minuut verlopen?
odoSecond = 0;
}
if (odoMinute == 60)
{
odoHour++; // uur verlopen?
odoMinute = 0;
}
//*********************display de tijd op nextion display ***************
char oTime[12];
sprintf(oTime, "%03d:%02d:%02d", odoHour, odoMinute, odoSecond);
Serial2.print(F("todo.txt=\""));
Serial2.print(oTime);
Serial2.print("\"");
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);
}

//******************Sub programma voor sessie timer ***********************************
void sessieTijd() // countup teller op page 1
{
timer = millis();
sesSecond++; // seconde verlopen
if (sesSecond == 60)
{
sesMinute++; // minuut verlopen?
sesSecond = 0;
}
if (sesMinute == 60)
{
sesHour++; // uur verlopen?
sesMinute = 0;
}
//*********************display de tijd op nextion display ***************
char sTime[10];
sprintf(sTime, "%02d:%02d:%02d", sesHour, sesMinute, sesSecond);
Serial2.print(F("tsessie.txt=\"")); //nog aan te maken
Serial2.print(sTime);
Serial2.print("\"");
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);
}

//******************Sub programma voor onderhoud timer ***********************************
void maintTijd() // countdown teller op page 1
{
if (mntSecond > 0)
{
mntSecond -= 1;
}
else if (mntMinute > 0)
{
mntSecond = 59;
mntMinute -= 1;
}
else if (mntHour > 0)
{
mntSecond = 59;
mntMinute = 59;
mntHour -= 1;
}
//*********************display de tijd op nextion display ***************
char mTime[10];
sprintf(mTime, "%02d:%02d", mntHour, mntMinute);
Serial2.print(F("tmaint.txt=\""));
Serial2.print(mTime);
Serial2.print("\"");
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);
}

[/code2]

het uitlezen van de eeprom


[/code2=ccp]
void leesTijd() // eenmalig inlezen op page 1
{
delay(500);
//*****************ophalen bewaarde resterende tijd tot Onderhoud****************************************
mntHour = EEPROM.read(EEPROM_MNT_UREN);
mntMinute = EEPROM.read(EEPROM_MNT_MINUTEN);

char mntTime[10];
sprintf(mntTime, "%02d:%02d", mntHour, mntMinute);
Serial2.print(F("tmaint.txt=\""));
Serial2.print(mntTime);
Serial2.print("\"");
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);

//******************Display ODO tijd op display 000:00:00***********************
odoHour = (EEPROM.read(EEPROM_ODO_UREN) * 256) + EEPROM.read(EEPROM_ODO_UREN + 1);
odoMinute = EEPROM.read(EEPROM_ODO_MINUTEN);
odoSecond = EEPROM.read(EEPROM_ODO_SECONDEN);

char oTime[12];
sprintf(oTime, "%03d:%02d:%02d", odoHour, odoMinute, odoSecond);
Serial2.print(F("todo.txt=\""));
Serial2.print(oTime);
Serial2.print("\"");
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);

//*******************************zet sessietijd op 00:00:00 *********************************************
char sTime[10];
sprintf(sTime, "%02d:%02d:%02d", sesHour, sesMinute, sesSecond);
Serial2.print(F("tsessie.txt=\"")); //nog aan te maken
Serial2.print(sTime);
Serial2.print("\"");
Serial2.write(0xff);
Serial2.write(0xff);
Serial2.write(0xff);
}


[/code2]

Terug naar C code

Wie is er online?

Gebruikers in dit forum: Geen geregistreerde gebruikers en 0 gasten