Eigen doseerprogramma?

Software die niet past in bovenstaande onderwerpen
Berichten: 328
Geregistreerd: 23 Okt 2016, 20:29

Eigen doseerprogramma?

Berichtdoor benvo » 24 Apr 2018, 14:49

Om een "eigen" doseerprogramma te maken ben ik begonnen om eens op te schrijven wat ik wil. Eerst in een kort zinnetje: Het op een bepaalde tijd een bepaalde hoeveelheid vloeistof doseren. Dit leek eenvoudig maar toen ik dit eens ging uitschrijven zaten er nog wel wat haken en ogen aan. Het uitgeschrevene heb ik in een flowchart vorm proberen te gieten van waaruit het volgende programma ontstond. Het programma draait op een Arduino Mega met een aangesloten Nextion scherm.

Let wel, ik ben me ervan bewust dat het onderstaande flink wat gebreken zal vertonen. Het kan zeker veel korter maar hoe, dat moet nog uitgevogeld worden. Ik heb geprobeerd iets te maken zonder knip en plakwerk waardoor er oplossingen instaan die anderen vast en zeker al veel beter hebben gemaakt. Om het programmeren voor de Arduino beter onder de knie te krijgen moet ik tenslotte ergens beginnen. Heel veel delen heb ik telkens uitgeprobeerd met ledjes en/of Serial.print.

Het programma werkt eigenlijk deels naar verwachting. Behalve het meest belangrijke: Op de vooraf ingestelde tijd waarop een hoeveelheid gedoseerd zou moeten worden hoor ik een tik. De tijd wordt dus gezien maar verder gebeurd er niets. Het probleem kan ik nog niet ontdekken maar jullie zien het misschien wel?

cpp code
Code: Alles selecteren
[code]

#include <Nextion.h>
#include "RTClib.h"
#include <Wire.h>
#include <EEPROM.h>
#include <EEPROMAnything.h>
#include <Adafruit_MotorShield.h>

//Maak het motorschildobject met het standaard I2C-adres
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
// Of maak het met een ander I2C-adres (bijvoorbeeld voor stapelen):Adafruit_MotorShield AFMS = Adafruit_MotorShield(0x61);

// Select which 'port' M1, M2, M3 or M4. In this case, M1
Adafruit_DCMotor *Motor1 = AFMS.getMotor(1);
Adafruit_DCMotor *Motor2 = AFMS.getMotor(2);
Adafruit_DCMotor *Motor3 = AFMS.getMotor(3);
Adafruit_DCMotor *Motor4 = AFMS.getMotor(4);

//RTC
RTC_DS3231 rtc;

//Time
DateTime CurrentTime;


//-----------------------Timerstrings----------------------

char Uur1String[5];
char Minuut1String[5];
char Seconde1String[5];
char Hoeveelheid1String[5];

char Uur2String[5];
char Minuut2String[5];
char Seconde2String[5];
char Hoeveelheid2String[5];

char Uur3String[5];
char Minuut3String[5];
char Seconde3String[5];
char Hoeveelheid3String[5];

char Uur4String[5];
char Minuut4String[5];
char Seconde4String[5];
char Hoeveelheid4String[5];


//------------------Variabelen---------------------------

unsigned long tijdMillis;                                          //klok update timer
unsigned long startTijd;                                           //kalibratie tijdmeting
unsigned long eindTijd;                                            //kalibratie tijdmeting

unsigned long duur1Millis;                                         //Gemeten tijd kalibratie pomp 1
unsigned long duur2Millis;                                         //Gemeten tijd kalibratie pomp 2
unsigned long duur3Millis;                                         //Gemeten tijd kalibratie pomp 3
unsigned long duur4Millis;                                         //Gemeten tijd kalibratie pomp 4

unsigned long motor1Millis;                                        //Timer motor 1 loop
unsigned long motor2Millis;                                        //Timer motor 2 loop
unsigned long motor3Millis;                                        //Timer motor 3 loop
unsigned long motor4Millis;                                        //Timer motor 4 loop

unsigned long mot1Millis;                                          //Timer totale motor 1 blok
unsigned long mot2Millis;                                          //Timer totale motor 2 blok
unsigned long mot3Millis;                                          //Timer totale motor 3 blok
unsigned long mot4Millis;                                          //Timer totale motor 4 blok

float duur1;                                               //Berekende tijdduur loop motor 1
float duur2;                                               //Berekende tijdduur loop motor 2
float duur3;                                               //Berekende tijdduur loop motor 3
float duur4;                                               //Berekende tijdduur loop motor 4

int adres1 = 50;                                                   //EEPROM adres motor 1
int adres2 = 60;                                                   //EEPROM adres motor 2
int adres3 = 70;                                                   //EEPROM adres motor 3
int adres4 = 80;                                                   //EEPROM adres motor 4

const int TxPin = 16;                                              //Tekstpin
long int tijdLoop;                                                 //Tijdloop berekening

uint32_t inhoud0;                                                 //Inhoud berekening voorraad flacon 1
uint32_t inhoud1;                                                 //Inhoud berekening voorraad flacon 2
uint32_t inhoud2;                                                 //Inhoud berekening voorraad flacon 3
uint32_t inhoud3;                                                 //Inhoud berekening voorraad flacon 4

int Uur1 = 0;                                                     //uur pomp 1
int Minuut1 = 0;                                                  //minuut pomp 1
int Seconde1 = 0;                                                 //seconde pomp 1

int Hoeveelheid1 = 0;                                             //hoeveelheid in ml. pomp 1

int Uur2 = 0;                                                     //uur pomp 2
int Minuut2 = 0;                                                  //minuut pomp 2
int Seconde2 = 0;                                                 //seconde pomp 2

int Hoeveelheid2 = 0;                                             //hoeveelheid in ml. pomp 2

int Uur3 = 0;                                                     //uur pomp 3
int Minuut3 = 0;                                                  //minuut pomp 3
int Seconde3 = 0;                                                 //seconde pomp 3

int Hoeveelheid3 = 0;                                             //hoeveelheid in ml. pomp 3

int Uur4 = 0;                                                     //uur pomp 4
int Minuut4 = 0;                                                  //minuut pomp 4
int Seconde4 = 0;                                                 //seconde pomp 4

int Hoeveelheid4 = 0;                                            //hoeveelheid in ml. pomp 4

int flacon1 = 0;                                                 //Definitie voorraad flacon 1
int flacon2 = 0;                                                 //Definitie voorraad flacon 2
int flacon3 = 0;                                                 //Definitie voorraad flacon 3
int flacon4 = 0;                                                 //Definitie voorraad flacon 4



/*---------------------------Nextion-----------------------------

  Deze knoppen en progress bars worden vanuit de Nextion bestuurd
  -----------------***-------------------------------------------

  Pagina 0 Instellingen
  NexButton b0 = NexButton(0, 3, "b0");                     //Instellingen

  Pagina 1 Menu
  NexButton b1 = NexButton(1, 5, "b1");                     //Thuis knop
  NexButton b2 = NexButton(1, 1, "b2");                     //Knop naar pomp test loop
  NexButton b3 = NexButton(1, 2, "b3");                     //Knop naar pomp kalibratie
  NexButton b4 = NexButton(1, 3, "b4");                     //Knop naar pompkeuze tijd/hoeveelheid
  NexButton b5 = NexButton(1, 4, "b5");                     //Knop vulling flacons

  Pagina 2 Pomp test loop
  NexButton b6 = NexButton(2, 5, "b6");                     //Thuis knop
  NexButton b7 = NexButton(2, 6, "b7");                     //Terug naar Menu

  Pagina 3 Pomp kalibratie
  NexButton b12 = NexButton(3, 5, "b12");                   //Thuis knop
  NexButton b13 = NexButton(3, 6, "b13");                   //Terug naar Menu

  Pagina 4 Pompkeuze tijd/hoeveelheid
  NexButton b18 = NexButton(4, 5, "b18");                   //Thuis knop
  NexButton b19 = NexButton(4, 5, "b19");                   //Terug naar Menu


  Pagina 5 tijd/hoeveelheid pomp 1
  NexButton b24 = NexButton(5, 2, "b24");                   //Thuis knop
  NexButton b25 = NexButton(5, 1, "b25");                   //Terug naar Pompkeuze tijd/hoeveelheid pagina 4

  Pagina 6 tijd/hoeveelheid pomp 2
  NexButton b34 = NexButton(6, 1, "b34");                   //Thuis knop
  NexButton b35 = NexButton(6, 2, "b35");                   //Terug naar Pompkeuze tijd/hoeveelheid pagina 4

  Pagina 7 tijd/hoeveelheid pomp 3
  NexButton b44 = NexButton(7, 1, "b44");                   //Thuis knop
  NexButton b45 = NexButton(7, 2, "b45");                   //Terug naar Pompkeuze tijd/hoeveelheid pagina 4

  Pagina 8 tijd/hoeveelheid pomp 4
  NexButton b54 = NexButton(8, 1, "b54");                   //Thuis knop
  NexButton b55 = NexButton(8, 2, "b55");                   //Terug naar Pompkeuze tijd/hoeveelheid pagina 4

  Pagina 9 Knop vulling flacons
  NexButton b64 = NexButton(9, 9, "b64");                   //Thuis knop
  NexButton b65 = NexButton(9, 10, "b65");                  //Terug naar Menu*/






//--------------------pagina 0: Dashboard-----------------------
NexText t0 = NexText(0, 1, "t0");                //uren, minuten en seconden (Klok veld)
NexText t1 = NexText(0, 2, "t1");                //Dag, maand en jaar (Datum veld)

//--------------------pagina 2: Pomp test loop-------------------
NexButton b8 = NexButton(2, 1, "b8");                       //Push and release knop pomp 1 start/stop test loop
NexButton b9 = NexButton(2, 2, "b9");                       //Push and release knop pomp 2 start/stop test loop
NexButton b10 = NexButton(2, 3, "b10");                     //Push and release knop pomp 3 start/stop test loop
NexButton b11 = NexButton(2, 4, "b11");                     //Push and release knop pomp 4 start/stop test loop

//--------------------pagina 3: Pomp kalibratie------------------
NexButton b14 = NexButton(3, 1, "b14");                     //Push and release knop pomp 1 start/stop kalibratie
NexButton b15 = NexButton(3, 2, "b15");                     //Push and release knop pomp 2 start/stop kalibratie
NexButton b16 = NexButton(3, 3, "b16");                     //Push and release knop pomp 3 start/stop kalibratie
NexButton b17 = NexButton(3, 4, "b17");                     //Push and release knop pomp 4 start/stop kalibratie

//--------------------pagina 4: Tijd en Hoeveelheid--------------
NexButton b20 = NexButton(4, 1, "b20");                     //Knop naar instelling pagina pomp 1
NexButton b21 = NexButton(4, 2, "b21");                     //Knop naar instelling pagina pomp 2
NexButton b22 = NexButton(4, 3, "b22");                     //Knop naar instelling pagina pomp 3
NexButton b23 = NexButton(4, 4, "b23");                     //Knop naar instelling pagina pomp 4

//--------------------pagina 5: instelling tijd/hoeveelheid pomp 1----
NexButton b26 = NexButton(5, 3, "b26");                     //Uur plus 1
NexButton b27 = NexButton(5, 4, "b27");                     //Uur min 1
NexButton b28 = NexButton(5, 5, "b28");                     //Minuut plus 1
NexButton b29 = NexButton(5, 6, "b29");                     //Minuut min 1
NexButton b30 = NexButton(5, 7, "b30");                     //Seconde plus 1
NexButton b31 = NexButton(5, 8, "b31");                     //Seconde min 1
NexButton b32 = NexButton(5, 9, "b32");                     //Milliliter plus 1
NexButton b33 = NexButton(5, 10, "b33");                    //Milliliter min 1

NexText t2 = NexText(5, 11, "t2");                          //uren instelling pomp 1
NexText t3 = NexText(5, 12, "t3");                          //minuten instelling pomp 1
NexText t4 = NexText(5, 13, "t4");                          //seconden instelling pomp 1
NexText t5 = NexText(5, 14, "t5");                          //Instelling hoeveelheid pomp 1

//--------------------pagina 6: instelling tijd/hoeveelheid pomp 2----
NexButton b36 = NexButton(6, 3, "b36");                     //Uur plus 1
NexButton b37 = NexButton(6, 4, "b37");                     //Uur min 1
NexButton b38 = NexButton(6, 5, "b38");                     //Minuut plus 1
NexButton b39 = NexButton(6, 6, "b39");                     //Minuut min 1
NexButton b40 = NexButton(6, 7, "b40");                     //Seconde plus 1
NexButton b41 = NexButton(6, 8, "b41");                     //Seconde min 1
NexButton b42 = NexButton(6, 9, "b42");                     //Milliliter plus 1
NexButton b43 = NexButton(6, 10, "b43");                     //Milliliter min 1

NexText t6 = NexText(6, 11, "t6");                          //uren instelling pomp 2
NexText t7 = NexText(6, 12, "t7");                          //minuten instelling pomp 2
NexText t8 = NexText(6, 13, "t8");                          //seconden instelling pomp 2
NexText t9 = NexText(6, 14, "t9");                          //Instelling hoeveelheid pomp 2


//--------------------pagina 7: instelling tijd/hoeveelheid pomp 3----
NexButton b46 = NexButton(7, 3, "b46");                     //Uur plus 1
NexButton b47 = NexButton(7, 4, "b47");                     //Uur min 1
NexButton b48 = NexButton(7, 5, "b48");                     //Minuut plus 1
NexButton b49 = NexButton(7, 6, "b49");                     //Minuut min 1
NexButton b50 = NexButton(7, 7, "b50");                     //Seconde plus 1
NexButton b51 = NexButton(7, 8, "b51");                     //Seconde min 1
NexButton b52 = NexButton(7, 9, "b52");                     //Milliliter plus 1
NexButton b53 = NexButton(7, 10, "b53");                    //Milliliter min 1

NexText t10 = NexText(7, 11, "t10");                        //uren instelling pomp 3
NexText t11 = NexText(7, 12, "t11");                        //minuten instelling pomp 3
NexText t12 = NexText(7, 13, "t12");                        //seconden instelling pomp 3
NexText t13 = NexText(7, 14, "t13");                        //Instelling hoeveelheid pomp 3


//--------------------pagina 8: instelling tijd/hoeveelheid pomp 4----
NexButton b56 = NexButton(8, 3, "b56");                     //Uur plus 1
NexButton b57 = NexButton(8, 4, "b57");                     //Uur min 1
NexButton b58 = NexButton(8, 5, "b58");                     //Minuut plus 1
NexButton b59 = NexButton(8, 6, "b59");                     //Minuut min 1
NexButton b60 = NexButton(8, 7, "b60");                     //Seconde plus 1
NexButton b61 = NexButton(8, 8, "b61");                     //Seconde min 1
NexButton b62 = NexButton(8, 9, "b62");                     //Milliliter plus 1
NexButton b63 = NexButton(8, 10, "b63");                    //Milliliter min 1

NexText t14 = NexText(8, 11, "t14");                        //uren instelling pomp 4
NexText t15 = NexText(8, 12, "t15");                        //minuten instelling pomp 4
NexText t16 = NexText(8, 13, "t16");                        //seconden instelling pomp 4
NexText t17 = NexText(8, 14, "t17");                        //Instelling hoeveelheid pomp 4


//--------------------pagina 9: Inhoud doseer flessen-------------
NexButton b66 = NexButton(9, 5, "b66");                     //vult flacon j0 tot 100
NexButton b67 = NexButton(9, 6, "b67");                     //vult flacon j1 tot 100
NexButton b68 = NexButton(9, 7, "b68");                     //vult flacon j2 tot 100
NexButton b69 = NexButton(9, 8, "b69");                     //vult flacon j3 tot 100

NexProgressBar j0 = NexProgressBar(9, 1, "j0");             //geeft inhoud aan van flacon j0
NexProgressBar j1 = NexProgressBar(9, 2, "j1");             //geeft inhoud aan van flacon j1
NexProgressBar j2 = NexProgressBar(9, 3, "j2");             //geeft inhoud aan van flacon j2
NexProgressBar j3 = NexProgressBar(9, 4, "j3");             //geeft inhoud aan van flacon j3


NexTouch *nex_listen_list[] =
{
  &b8,
  &b9,
  &b10,
  &b11,
  &b14,
  &b15,
  &b16,
  &b17,
  &b20,
  &b21,
  &b22,
  &b23,
  &b26,
  &b27,
  &b28,
  &b29,
  &b30,
  &b31,
  &b32,
  &b33,
  &b36,
  &b37,
  &b38,
  &b39,
  &b40,
  &b41,
  &b42,
  &b43,
  &b46,
  &b47,
  &b48,
  &b49,
  &b50,
  &b51,
  &b52,
  &b53,
  &b56,
  &b57,
  &b58,
  &b59,
  &b60,
  &b61,
  &b62,
  &b63,
  &b66,
  &b67,
  &b68,
  &b69,
  &t0,
  &t1,
  &t2,
  &t3,
  &t4,
  &t5,
  &t6,
  &t7,
  &t8,
  &t9,
  &t10,
  &t11,
  &t12,
  &t13,
  &t14,
  &t15,
  &t16,
  &t17,
  NULL
};
//----------------------Pomp test loop Pagina 2-----------------

void b8PushCallback(void *ptr)
{
  Motor1 ->run(FORWARD);
  Motor1->setSpeed(255);
}
void b8PopCallback(void *ptr)
{
  Motor1 ->run(RELEASE);
}

void b9PushCallback(void *ptr)
{
  Motor2 ->run(FORWARD);
  Motor2->setSpeed(255);
}
void b9PopCallback(void *ptr)
{
  Motor2 ->run(RELEASE);
}

void b10PushCallback(void *ptr)
{
  Motor3 ->run(FORWARD);
  Motor3->setSpeed(255);
}
void b10PopCallback(void *ptr)
{
  Motor3 ->run(RELEASE);
}

void b11PushCallback(void *ptr)
{
  Motor4 ->run(FORWARD);
  Motor4->setSpeed(255);
}
void b11PopCallback(void *ptr)
{
  Motor4 ->run(RELEASE);
}

//-------------------------Pomp kalibratie Pagina 3--------------------
//10 ml. wordt overgepompt, hiervoor wordt de benodigde tijd vastgelegd.

void b14PushCallback(void *ptr)
{
  if (tijdLoop == 0)
  {
    Motor1 ->run(FORWARD);
    Motor1->setSpeed(255);
    startTijd = millis();
    tijdLoop = 1;
  }
}
void b14PopCallback(void *ptr)
{
  if (tijdLoop == 1)
  {
    Motor1 ->run(RELEASE);
    eindTijd = millis();
    tijdLoop = 0;
    duur1 = eindTijd - startTijd;
    duur1 /= 10;                        //omzetting 10 ml. kalibratieduur naar 1 ml.
    EEPROM_writeAnything(adres1, duur1);
  }
}

void b15PushCallback(void *ptr)
{
  if (tijdLoop == 0)
  {
    Motor2 ->run(FORWARD);
    Motor2->setSpeed(255);
    startTijd = millis();
    tijdLoop = 1;
  }
}
void b15PopCallback(void *ptr)
{
  if (tijdLoop == 1)
  {
    Motor2 ->run(RELEASE);
    eindTijd = millis();
    tijdLoop = 0;
    duur2 = eindTijd - startTijd;
    duur2 /= 10;
    EEPROM_writeAnything(adres2, duur2);
  }
}

void b16PushCallback(void *ptr)
{
  if (tijdLoop == 0)
  {
    Motor3 ->run(FORWARD);
    Motor3->setSpeed(255);
    startTijd = millis();
    tijdLoop = 1;
  }
}
void b16PopCallback(void *ptr)
{
  if (tijdLoop == 1)
  {
    Motor3 ->run(RELEASE);
    eindTijd = millis();
    tijdLoop = 0;
    duur3 = eindTijd - startTijd;
    duur3 /= 10;
    EEPROM_writeAnything(adres3, duur3);
  }
}

void b17PushCallback(void *ptr)
{
  if (tijdLoop == 0)
  {
    Motor4 ->run(FORWARD);
    Motor4->setSpeed(255);
    startTijd = millis();
    tijdLoop = 1;
  }
}
void b17PopCallback(void *ptr)
{
  if (tijdLoop == 1)
  {
    Motor4 ->run(RELEASE);
    eindTijd = millis();
    tijdLoop = 0;
    duur4 = eindTijd - startTijd;
    duur4 /= 10;
    EEPROM_writeAnything(adres4, duur4);
  }
}


//----------------------pagina 4 naar instelling pagina pomp 1----------

void b20PopCallback(void *ptr)
{
  sprintf(Uur1String, "%02d", Uur1);
  t2.setText(Uur1String);

  sprintf(Minuut1String, "%02d", Minuut1);
  t3.setText(Minuut1String);

  sprintf(Seconde1String, "%02d", Seconde1);
  t4.setText(Seconde1String);

  sprintf(Hoeveelheid1String, "%02d", Hoeveelheid1);
  t5.setText(Hoeveelheid1String);
}

//----------------------pagina 5 instelling tijd/hoeveelheid pomp 1--------

void b26PopCallback(void *ptr)
{
  Uur1 += 1;
  sprintf(Uur1String, "%02d", Uur1);
  t2.setText(Uur1String);

}
void b27PopCallback(void *ptr)
{
  Uur1 -= 1;
  sprintf(Uur1String, "%02d", Uur1);
  t2.setText(Uur1String);

}

void b28PopCallback(void *ptr)
{
  Minuut1 += 1;
  sprintf(Minuut1String, "%02d", Minuut1);
  t3.setText(Minuut1String);
}
void b29PopCallback(void *ptr)
{
  Minuut1 -= 1;
  sprintf(Minuut1String, "%02d", Minuut1);
  t3.setText(Minuut1String);
}

void b30PopCallback(void *ptr)
{
  Seconde1 += 1;
  sprintf(Seconde1String, "%02d", Seconde1);
  t4.setText(Seconde1String);
  delay(100);
}

void b31PopCallback(void *ptr)
{
  Seconde1 -= 1;
  sprintf(Seconde1String, "%02d", Seconde1);
  t4.setText(Seconde1String);
}


void b32PopCallback(void *ptr)

{
  Hoeveelheid1 += 1;
  sprintf(Hoeveelheid1String, "%02d", Hoeveelheid1);
  t5.setText(Hoeveelheid1String);
}
void b33PopCallback(void *ptr)
{
  Hoeveelheid1 -= 1;
  sprintf(Hoeveelheid1String, "%02d", Hoeveelheid1);
  t5.setText(Hoeveelheid1String);
}

//-----------------------pagina 4 naar instelling pagina pomp 2----------

void b21PopCallback(void *ptr)

{
  sprintf(Uur2String, "%02d", Uur2);
  t6.setText(Uur2String);

  sprintf(Minuut2String, "%02d", Minuut2);
  t7.setText(Minuut2String);

  sprintf(Seconde2String, "%02d", Seconde2);
  t8.setText(Seconde2String);

  sprintf(Hoeveelheid2String, "%02d", Hoeveelheid2);
  t9.setText(Hoeveelheid2String);
}

//------------------------pagina 6 instelling tijd/hoeveelheid pomp 2-------

void b36PopCallback(void *ptr)
{
  Uur2 += 1;
  sprintf(Uur2String, "%02d", Uur2);
  t6.setText(Uur2String);
}
void b37PopCallback(void *ptr)
{
  Uur2 -= 1;
  sprintf(Uur2String, "%02d", Uur2);
  t6.setText(Uur2String);
}

void b38PopCallback(void *ptr)
{
  Minuut2 += 1;
  sprintf(Minuut2String, "%02d", Minuut2);
  t7.setText(Minuut2String);
}
void b39PopCallback(void *ptr)
{
  Minuut2 -= 1;
  sprintf(Minuut2String, "%02d", Minuut2);
  t7.setText(Minuut2String);
}


void b40PopCallback(void *ptr)
{
  Seconde2 += 1;
  sprintf(Seconde2String, "%02d", Seconde2);
  t8.setText(Seconde2String);
}
void b41PopCallback(void *ptr)
{
  Seconde2 -= 1;
  sprintf(Seconde2String, "%02d", Seconde2);
  t8.setText(Seconde2String);
}


void b42PopCallback(void *ptr)
{
  Hoeveelheid2 += 1;
  sprintf(Hoeveelheid2String, "%02d", Hoeveelheid2);
  t9.setText(Hoeveelheid2String);
}
void b43PopCallback(void *ptr)
{
  Hoeveelheid2 -= 1;
  sprintf(Hoeveelheid2String, "%02d", Hoeveelheid2);
  t9.setText(Hoeveelheid2String);
}


//-----------------------pagina 4 naar instelling pagina  pomp 3----------

void b22PopCallback(void *ptr)

{
  sprintf(Uur3String, "%02d", Uur3);
  t10.setText(Uur3String);

  sprintf(Minuut3String, "%02d", Minuut3);
  t11.setText(Minuut3String);

  sprintf(Seconde3String, "%02d", Seconde3);
  t12.setText(Seconde3String);

  sprintf(Hoeveelheid3String, "%02d", Hoeveelheid3);
  t13.setText(Hoeveelheid3String);
}

//------------------------pagina 7 instelling tijd/hoeveelheid pomp 3-------

void b46PopCallback(void *ptr)
{
  Uur3 += 1;
  sprintf(Uur3String, "%02d", Uur3);
  t10.setText(Uur3String);
}
void b47PopCallback(void *ptr)
{
  Uur3 -= 1;
  sprintf(Uur3String, "%02d", Uur3);
  t10.setText(Uur3String);
}

void b48PopCallback(void *ptr)
{
  Minuut3 += 1;
  sprintf(Minuut3String, "%02d", Minuut3);
  t11.setText(Minuut3String);
}
void b49PopCallback(void *ptr)
{
  Minuut3 -= 1;
  sprintf(Minuut3String, "%02d", Minuut3);
  t11.setText(Minuut3String);
}


void b50PopCallback(void *ptr)
{
  Seconde3 += 1;
  sprintf(Seconde3String, "%02d", Seconde3);
  t12.setText(Seconde3String);
}
void b51PopCallback(void *ptr)
{
  Seconde3 -= 1;
  sprintf(Seconde3String, "%02d", Seconde3);
  t12.setText(Seconde3String);
}


void b52PopCallback(void *ptr)
{
  Hoeveelheid3 += 1;
  sprintf(Hoeveelheid3String, "%02d", Hoeveelheid3);
  t13.setText(Hoeveelheid3String);
}
void b53PopCallback(void *ptr)
{
  Hoeveelheid3 -= 1;
  sprintf(Hoeveelheid3String, "%02d", Hoeveelheid3);
  t13.setText(Hoeveelheid3String);
}


//-----------------------pagina 4 naar instelling pagina pomp 4---------

void b23PopCallback(void *ptr)

{
  sprintf(Uur4String, "%02d", Uur4);
  t14.setText(Uur4String);

  sprintf(Minuut4String, "%02d", Minuut4);
  t15.setText(Minuut4String);

  sprintf(Seconde4String, "%02d", Seconde4);
  t16.setText(Seconde4String);

  sprintf(Hoeveelheid4String, "%02d", Hoeveelheid4);
  t17.setText(Hoeveelheid4String);
}

//------------------------pagina 8 instelling tijd/hoeveelheid pomp 4-------

void b56PopCallback(void *ptr)
{
  Uur4 += 1;
  sprintf(Uur4String, "%02d", Uur4);
  t14.setText(Uur4String);
}
void b57PopCallback(void *ptr)
{
  Uur4 -= 1;
  sprintf(Uur4String, "%02d", Uur4);
  t14.setText(Uur4String);
}

void b58PopCallback(void *ptr)
{
  Minuut4 += 1;
  sprintf(Minuut4String, "%02d", Minuut4);
  t15.setText(Minuut4String);
}
void b59PopCallback(void *ptr)
{
  Minuut4 -= 1;
  sprintf(Minuut4String, "%02d", Minuut4);
  t15.setText(Minuut4String);
}


void b60PopCallback(void *ptr)
{
  Seconde4 += 1;
  sprintf(Seconde4String, "%02d", Seconde4);
  t16.setText(Seconde4String);
}
void b61PopCallback(void *ptr)
{
  Seconde4 -= 1;
  sprintf(Seconde4String, "%02d", Seconde4);
  t16.setText(Seconde4String);
}


void b62PopCallback(void *ptr)
{
  Hoeveelheid4 += 1;
  sprintf(Hoeveelheid4String, "%02d", Hoeveelheid4);
  t17.setText(Hoeveelheid4String);
}
void b63PopCallback(void *ptr)
{
  Hoeveelheid4 -= 1;
  sprintf(Hoeveelheid4String, "%02d", Hoeveelheid4);
  t17.setText(Hoeveelheid4String);
}

//--------------------Zet de inhoud van de flacons op 100-------------

void b66PopCallback(void *ptr)
{
  flacon1 = 500;
  inhoud0 = flacon1 * 20 / 100;
  j0.setValue(inhoud0);
}

void b67PopCallback(void *ptr)
{
  flacon2 = 500;
  inhoud1 = flacon2 * 20 / 100;
  j1.setValue(inhoud1);
}

void b68PopCallback(void *ptr)
{
  flacon3 = 500;
  inhoud2 = flacon3 * 20 / 100;
  j2.setValue(inhoud2);
}

void b69PopCallback(void *ptr)
{
  flacon4 = 500;
  inhoud3 = flacon4 * 20 / 100;
  j3.setValue(inhoud3);
}


void setup()
{
  Wire.begin();

  //KLOK
  rtc.begin();           //Start klok

  nexInit();            //Initialisatie Nextion scherm

  //Merkt de tekstvensters op
  //t0.attachPop(t0PopCallback, &t0);
  //t1.attachPop(t1PopCallback, &t1);


  //Merkt pressed and released buttons op

  b8.attachPush(b8PushCallback, &b8);
  b9.attachPush(b9PushCallback, &b9);
  b10.attachPush(b10PushCallback, &b10);
  b11.attachPush(b11PushCallback, &b11);

  b8.attachPop(b8PopCallback, &b8);
  b9.attachPop(b9PopCallback, &b9);
  b10.attachPop(b10PopCallback, &b10);
  b11.attachPop(b11PopCallback, &b11);

  b14.attachPush(b14PushCallback, &b14);
  b15.attachPush(b15PushCallback, &b15);
  b16.attachPush(b16PushCallback, &b16);
  b17.attachPush(b17PushCallback, &b17);

  b14.attachPop(b14PopCallback, &b14);
  b15.attachPop(b15PopCallback, &b15);
  b16.attachPop(b16PopCallback, &b16);
  b17.attachPop(b17PopCallback, &b17);




  b20.attachPop(b20PopCallback, &b20);
  b21.attachPop(b21PopCallback, &b21);
  b22.attachPop(b22PopCallback, &b22);
  b23.attachPop(b23PopCallback, &b23);

  b26.attachPop(b26PopCallback, &b26);
  b27.attachPop(b27PopCallback, &b27);
  b28.attachPop(b28PopCallback, &b28);
  b29.attachPop(b29PopCallback, &b29);
  b30.attachPop(b30PopCallback, &b30);
  b31.attachPop(b31PopCallback, &b31);
  b32.attachPop(b32PopCallback, &b32);
  b33.attachPop(b33PopCallback, &b33);

  b36.attachPop(b36PopCallback, &b36);
  b37.attachPop(b37PopCallback, &b37);
  b38.attachPop(b38PopCallback, &b38);
  b39.attachPop(b39PopCallback, &b39);
  b40.attachPop(b40PopCallback, &b40);
  b41.attachPop(b41PopCallback, &b41);
  b42.attachPop(b42PopCallback, &b42);
  b43.attachPop(b43PopCallback, &b43);

  b46.attachPop(b46PopCallback, &b46);
  b47.attachPop(b47PopCallback, &b47);
  b48.attachPop(b48PopCallback, &b48);
  b49.attachPop(b49PopCallback, &b49);
  b50.attachPop(b50PopCallback, &b50);
  b51.attachPop(b51PopCallback, &b51);
  b52.attachPop(b52PopCallback, &b52);
  b53.attachPop(b53PopCallback, &b53);

  b56.attachPop(b56PopCallback, &b56);
  b57.attachPop(b57PopCallback, &b57);
  b58.attachPop(b58PopCallback, &b58);
  b59.attachPop(b59PopCallback, &b59);
  b60.attachPop(b60PopCallback, &b60);
  b61.attachPop(b61PopCallback, &b61);
  b62.attachPop(b62PopCallback, &b62);
  b63.attachPop(b63PopCallback, &b63);

  b66.attachPop(b66PopCallback, &b66);
  b67.attachPop(b67PopCallback, &b67);
  b68.attachPop(b68PopCallback, &b68);
  b69.attachPop(b69PopCallback, &b69);

  AFMS.begin();  // maak met de standaardfrequentie 1.6KHz
  //AFMS.begin(1000);  // of, zoals hier aangegeven, met een andere frequentie, zeg 1 KHz

  pinMode(TxPin, OUTPUT);           //TxPin wordt als uitgang gebruikt

  //rtc.adjust(DateTime(2018,4,18,11,53,0));        //Stelt de RTC tijd in op de sketch, wordt gebruikt voor één run. De tijd wordt gereset op het moment dat het apparaat wordt gereset!
}


void loop()
{

  nexLoop(nex_listen_list);

  //Stelt in op huidige tijd
  CurrentTime = rtc.now();
  //-------------------------------------Motor 1----------------------------------

  DateTime now = rtc.now();
  if (now.hour() == Uur1 && now.minute() == Minuut1) && now.second() == Seconde1) //Startijd
  {
    unsigned long mot1 = millis();
    if (mot1 - mot1Millis >= 10000)
    {
      duur1 = EEPROM_readAnything(adres1, duur1);                                  //Ophalen tijdsduur voor 1 ml dosering
      duur1 = duur1 * Hoeveelheid1;                                                //Gewenste doseerhoeveelheid
      unsigned long motor1Millis;                                                  //Duur motor1 aan.
      if (motor1Millis - duur1Millis < duur1)
      {
        Motor1 ->run(FORWARD);
        Motor1->setSpeed(255);
        duur1Millis = motor1Millis;
      }
    }

    Motor1 ->run(RELEASE);                                                          //Motor1 uit

    flacon1 = flacon1 - Hoeveelheid1;
    inhoud0 = flacon1 * 20 / 100;
    j0.setValue(inhoud0);                                                           //Rest flacon inhoud
    mot1Millis = mot1;
  }
  //------------------------------------Motor 2-----------------------------------

  if (now.hour() == Uur2 && now.minute() == Minuut2 && now.second() == Seconde2) //Startijd
  {
    unsigned long mot2 = millis();
    if (mot2 - mot2Millis >= 10000)
    {
      duur2 = EEPROM_readAnything(adres2, duur2);                                  //Ophalen tijdsduur voor 1 ml dosering
      duur2 = duur2 * Hoeveelheid2;                                                //Gewenste doseerhoeveelheid
      unsigned long motor2Millis;                                                  //Duur motor2 aan.
      if (motor2Millis - duur2Millis < duur2)
      {
        Motor2 ->run(FORWARD);
        Motor2->setSpeed(255);
        duur2Millis = motor2Millis;
      }
    }


    Motor2 ->run(RELEASE);                                                          //Motor2 uit

    flacon2 = flacon2 - Hoeveelheid2;
    inhoud1 = flacon2 * 20 / 100;
    j1.setValue(inhoud1);                                                           //Rest flacon inhoud
    mot2Millis = mot2;
  }
  //------------------------------------Motor 3------------------------------------

  if (now.hour() == Uur3 && now.minute() == Minuut3 && now.second() == Seconde3) //Startijd
  {
    unsigned long mot3 = millis();
    if (mot3 - mot3Millis >= 10000)
    {
      duur3 = EEPROM_readAnything(adres3, duur3);                                  //Ophalen tijdsduur voor 1 ml dosering
      duur3 = duur3 * Hoeveelheid3;                                                //Gewenste doseerhoeveelheid
      unsigned long motor3Millis;                                                  //Duur motor3 aan.
      if (motor3Millis - duur3Millis < duur3)
      {
        Motor3 ->run(FORWARD);
        Motor3->setSpeed(255);
        duur3Millis = motor3Millis;
      }
    }

    Motor3 ->run(RELEASE);                                                          //Motor3 uit

    flacon3 = flacon3 - Hoeveelheid3;
    inhoud2 = flacon3 * 20 / 100;
    j2.setValue(inhoud2);                                                           //Rest flacon inhoud
    mot3Millis = mot3;
  }
  //----------------------------------Motor 4-------------------------------------

  if (now.hour() == Uur4 && now.minute() == Minuut4 && now.second() == Seconde4) //Startijd
  {
    unsigned long mot4 = millis();
    if (mot4 - mot4Millis >= 10000)
    {
      duur4 = EEPROM_readAnything(adres4, duur4);                                  //Ophalen tijdsduur voor 1 ml dosering
      duur4 = duur4 * Hoeveelheid4;                                                //Gewenste doseerhoeveelheid
      unsigned long motor4Millis;                                                  //Duur motor4 aan.
      if (motor4Millis - duur4Millis < duur4)
      {
        Motor4 ->run(FORWARD);
        Motor4->setSpeed(255);
        duur4Millis = motor4Millis;
      }
    }

    Motor4 ->run(RELEASE);                                                          //Motor4 uit

    flacon4 = flacon4 - Hoeveelheid4;
    inhoud3 = flacon4 * 20 / 100;
    j3.setValue(inhoud3);                                                           //Rest flacon inhoud*/
    mot4Millis = mot4;
  }

  // Tijd en datum update
  unsigned long huidigetijdMillis = millis();
  if (huidigetijdMillis - tijdMillis > 1000)
  {
    DateTime now = rtc.now();
    char tijdString[9];
    static char vorigeTijd[9];

    sprintf(tijdString, "%02d:%02d:%02d", now.hour(), now.minute(), now.second());

    if (strcmp(tijdString, vorigeTijd) != 0)
    {
      t0.setText (tijdString);                                                   //Tijd update
      strcpy(vorigeTijd, tijdString);                                            //Bewaar vorigeTijd voor de volgende vergelijking
    }



    char datumString[9];
    static char vorigeDatum[9];

    sprintf(datumString, "%02d-%02d-%02d", now.day(), now.month(), now.year());

    if (strcmp(datumString, vorigeDatum) != 0)
    {
      t1.setText (datumString);                                                //Datum update
      strcpy(vorigeDatum, datumString);                                        //Bewaar vorigeDatum voor de volgende vergelijking
    }
    tijdMillis = huidigetijdMillis;
  }

}
[/code]

Advertisement

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

Re: Eigen doseerprogramma?

Berichtdoor Koepel » 24 Apr 2018, 18:03

Heb je het Adafruit V2 Motor Shield ? Dat is mooi.
https://www.adafruit.com/product/1438

Heb je dat al geprobeerd of dat werkt zonder de andere code ?

Kun je uitleggen hoe je de tijd gebruikt ?
Ik heb namelijk al moeite met de eerste regel zoals deze:
Code: Alles selecteren
if (now.hour() == Uur1 && now.minute() == Minuut1) && now.second() == Seconde1)

Wanneer de loop() duizenden keren per seconde wordt gedaan, dan is dat gedurende een seconde altijd actief.
En als de code ergens een seconde duurt, dan mis je dat moment.
De ideale situatie is wanneer er eenmalig iets actief wordt, zonder de kans dat het moment gemist wordt.

De TimeLib samen met TimeAlarms library kan dat.
Gebruik je de Adafruit RTClib ? Ik weet zo niet uit mijn hoofd hoe zo iets als TimeAlarms daarmee gedaan wordt.

Kijk nog eens even naar die regel code. Zie je daar een ')' te veel in staan ?

Je kunt of de ene code tags gebruikt of de andere code tags.
De knop "Code" geeft de code tags: [ code ] en [ /code ] .
De "Select a Syntax" en dan "C++" geeft de code tags: [ code2=cpp ] en [ /code2 ] .

Berichten: 328
Geregistreerd: 23 Okt 2016, 20:29

Re: Eigen doseerprogramma?

Berichtdoor benvo » 24 Apr 2018, 19:02

Hallo Koepel,

Inderdaad heb ik een MotorShield, zij het van Chinese makelij. Dit shield werk perfect. Wanneer ik de test loop push/release knoppen gebruik loopt elke motor naar behoren evenals bij de kalibratie.
Even hoe de kalibratie is bedoelt: De knoppen werken ook met push en release. Druk ik de (kalibratie-)knop in dan hou ik deze vast en loopt de motor voor een dosering van 10 ml. vloeistof. Wanneer ik de knop loslaat dan stopt de motor. De tussenliggende tijd wordt gemeten en gedeeld door 10 zodat ik weet hoelang de motor zou moeten draaien om 1 ml. af te geven. Deze "duur" wordt vastgelegd in EEPROM. Wanneer ik de knop tijd/hoeveelheid indruk komt er een scherm tevoorschijn waarin ik de uren, minuten en seconden vastleg waarop de motor zou moeten starten. Op dit scherm vul ik ook een hoeveelheid in ml. in. Bijvoorbeeld 2 ml. Die hoeveelheid wordt dan vermenigvuldigd met de duur zodat op de gewenst tijd de juiste dosering wordt gedaan. Op dit invulscherm kan ik met plusjes en minnetjes bijvoorbeeld voor de uren "14" invullen, minuten "30" en seconden "10". Zo'n tijd vergelijk ik dan met de kloktijd. Dus als "now.hour()" 14 komt dit overeen met het ingevulde uur 14. Evenzo met de minuten en seconden. Dit schijnt wel te werken, op de ingestelde tijd hoor ik een duidelijke tik. Bovendien heb ik dit deel ook eens getest met een ledje dat keurig aanging op de ingestelde tijd.
Overigens dacht ik ook aan de mogelijkheid dat de seconde gemist zou worden en heb toen getest met alleen uren en minuten. Met hetzelfde resultaat. Timealarms heb ik wel aan gedacht maar dit werkt slecht samen met de RTClib library van Adafruit waar, heel verwarrend, er overigens twee verschillende versies van bestaan onder dezelfde naam. Zou ik trouwens niet nodig moeten hebben, er vanuit gaande dat deze manier, zie de ledproef, zou moeten werken. Heb ik alles zo duidelijk beschreven? Dit zo beziende denk ik dat het probleem toch misschien elders ligt?

Berichten: 328
Geregistreerd: 23 Okt 2016, 20:29

Re: Eigen doseerprogramma?

Berichtdoor benvo » 24 Apr 2018, 19:33

Hier laat ik voor de duidelijkheid nog even mijn Nextion scherm afbeeldingen zien.

Afbeelding

Op het dashboard (foto linksboven) staat bovenin het kader de tijd. In het kader daaronder de datum.

Groet,
Ben.

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

Re: Eigen doseerprogramma?

Berichtdoor Koepel » 25 Apr 2018, 09:29

Meerdere RTC en Time libraries
Het is een beetje een rommeltje met de RTC en Time libraries. Het Arduino team zou een keuze kunnen maken en die aan de standaard Arduino libraries kunnen toevoegen, maar zo ver is het nog niet.

Adafruit Motor Shield V2 clone
Dit motor shield ? https://www.aliexpress.com/item/1-x-Standard-I2C-TB6612-Mosfet-Stepper-Motor-PCA9685-PWM-Servo-Driver-Shield-V2-Robot-Uno/32836075504.html.
Ik wist niet dat ze van versie V2 ook clones maken.
Het is niet belangrijk voor je vraag, maar ik wil me kunnen voorstellen hoe je project er uit ziet ;)

Arrays te klein
Je tijdString[9], vorigeTijd[9], datumString[9], vorigeDatum[9] zijn allemaal 9 bytes. Kun je die 16 maken ?
De now.year() geeft vier cijfers terug, en de "%02d" is het minimum aantal tekens. Met de now.year() overschrijf je de stack. Dat is een echte bug.
Ik krijg een déjà-vu gevoel, heb ik dit misschien al eerder genoemd ?

EEPROMAnything.h
Wist je dat de EEPROMAnything aan de Arduino EEPROM library is toegevoegd ?
Dat zijn de functies EEPROM.get() en EEPROM.put().
https://www.arduino.cc/en/Reference/EEPROMGet
https://www.arduino.cc/en/Reference/EEPROMPut
Je zou die kunnen gebruiken en dan hoef je de EEPROMAnything library niet toe te voegen.

CurrentTime
Je gebruikt de variabele CurrentTime niet, die kun je weghalen.
De RTC loopt gewoon door, het is niet nodig om iets op de huidige tijd in te stellen.

Iets op een bepaald moment doen
Helaas heb ik niet kunnen vinden wat de meest gangbare manier is om met de Adafruit RTClib iets op een bepaalde tijd te doen.
Als ik ga zoeken dan zie ik als antwoord om de TimeLib en TimeAlarms te gebruiken, en dat is ook mijn advies.

Als je toch met de Adafruit RTClib wilt door gaan, dan gaat het er om dat je eenmalig iets doet. Ik zou met een variabele bijhouden of dat al gedaan is.
Je gebruik van millis() vind ik wat vreemd, volgens mij kun je net zo goed een delay() doen.

Wil je meerdere pompen om hetzelfde moment doen ? Of een andere pomp starten terwijl een pomp nog bezig is ? Dan is het nodig om heel de code anders te schrijven.

Wordt er niet meer dan één keer uur de pomp aangezet ? Dan is dat te gebruiken om de variabele terug te zetten.

Volgens mij is het nodig om het aantal seconden sinds 1970 te gebruiken om iets op een bepaalde tijd te doen. Het kan anders gemakkelijk verkeerd gaan.
Het onderstaande voorbeeld is dus geen goede code. Let op het ">=" teken bij de seconden. Dat is helaas niet veilig want als de seconden 59 is, dan maakt de ">=" geen verschil.

Code: Alles selecteren
bool motor1_al_gedaan = false;    // globale variabele

...

  if (now.hour() == Uur2 && now.minute() == Minuut2 && now.second() >= Seconde2 && !motor1_al_gedaan) //Startijd
  {
    duur2 = EEPROM_readAnything(adres2, duur2);    //Ophalen tijdsduur voor 1 ml dosering
    duur2 = duur2 * Hoeveelheid2;               //Gewenste doseerhoeveelheid
    Motor2 ->run(FORWARD);
    Motor2->setSpeed(255);

    delay( duur2);             // laat de motor lopen
 
    Motor2 ->run(RELEASE);     //Motor2 uit
 
    flacon2 = flacon2 - Hoeveelheid2;
    inhoud1 = flacon2 * 20 / 100;
    j1.setValue(inhoud1);     //Rest flacon inhoud

    motor1_al_gedaan = true;  // zet op 'true' om te voorkomen dat het meerdere keren wordt uitgevoerd.
  }

  if( now.hour != Uur2)
  {
    motor1_al_gedaan = false;     // reset de variabele
  }

Misschien is het nodig om de "motor1_al_gedaan = false;" ook toe te voegen bij de Nextion callback functies. Wanneer de motor net heeft gelopen en je stelt een nieuwe tijd in die over 5 minuten is, dan wil je dat de pomp het gaan doen, en niet eerst gaat wachten totdat het uur voorbij is.

Berichten: 328
Geregistreerd: 23 Okt 2016, 20:29

Re: Eigen doseerprogramma?

Berichtdoor benvo » 25 Apr 2018, 11:38

Hallo Koepel,

Dit was mijn bestelling bij de Chinezen:
https://nl.aliexpress.com/item/Standard ... 0.0.l3E6Ls
Dus een vergelijkbare met het apparaat dat jij liet zien.

De tijd en datum strings heb ik op 16 gezet.
Now.year zette ik op %04d waarmee de datum verdween. Domkop dat ik ben, de voorloop nul is hier ook niet nodig,
%4d is voldoende en dit werkt dan ook.

Ik wist inderdaad niet niet dat EEPROMAnything al in de Arduino library stond.Overigens heb ik dit pas later toegevoegd. Aanvankelijk had ik EEPROM.write en EEPROM.read staan.
Nu dus gewijzigd naar Put en Get. Is er eigenlijk een verschil tussen write/Put en read/Get?

De variabele CurrentTime heb ik weggehaald. Daar heb ik overheen gekeken, ik weet dat dit overbodig is.

Je laatste tips vind ik erg goed! Daar heb ik te weinig bij nagedacht, ik moet aangegeven dat ik eenmalig iets doe! Mijn doseersysteem is bedoelt voor bemesting van mijn aquarium.
Eigenlijk behoor je dat maar een keer per dag, en dan gaat het om enkele mililiters, te doen.
Het is de bedoeling dat er een basisvoeding, elke dag 2 ml. Gegeven wordt
Verder nitraat (NO3) ook 2 ml. per dag.
Fosfaat (PO4), 2 ml. per dag.
Tenslotte Ferro (FE) 1 ml. Per dag.
Maar… Ferro mag niet gemixt worden met nitraat en/fosfaat.
Daar kan je per dag bijvoorbeeld een uur of 12 tussen laten zitten. Kan natuurlijk ook anders:
Daarom had ik bedacht om op elke andere dag, ofwel om de dag te doseren.
Dag A: Basis 2ml., nitraat en fosfaat elk 4 ml.
Dag B: Basis 2 ml. en Ferro 2 ml.

Bijvoorbeeld zo:
//Om de dag A:
if (a==0){
analogWrite(pomp1, 255); //pomp 1 start (Basis)
analogWrite(pomp2, 255); //pomp 2 start (nitraat)
analogWrite(pomp3, 255); //pomp 3 start (fosfaat)
delay(doseerlengte) ; //middels delay doseertijd en duur hoeveelheid bepalen.
analogWrite(pomp1, 0); //pomp 1 stopt
delay(doseerlengte); //doseer tijd voor pomp 2 en 3 verdubbelt
analogWrite(pomp2, 0); //pomp 2 stopt
analogWrite(pomp3, 0); //pomp 3 stopt
a=1;
}
//Om de dag B:
else{
analogWrite(pomp1, 255); //pomp 1 start (basis)
analogWrite(pomp4, 255); //pomp4 start (Ferro)
delay(doseerlengte); //doseertijd
analogWrite pomp1, 0); //pomp 1 stopt
analogWrite pomp4, 0); //pomp 4 stopt
Maar misschien is het toch handiger om per dag te doseren met een ruime tijd daartussen.


TimeLib en TimeAlarms wil ik toch nog eens bezien. Misschien liggen daar betere kansen.
Toch denk ik dat we beiden in dezelfde richting denken. Een Nextion scherm kan, voor zover ik weet, de boel niet altijd bijbenen. Er worden ook altijd “retour” reacties gegeven. Kan daar iets uitgeschakeld worden? Een andere vraag is: De testloop ben je niet altijd nodig net zomin als de kalibratie. Ook de tijden/hoeveelheden stel je in, meer is daarna niet nodig. Misschien zie jij daar mogelijkheden?

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

Re: Eigen doseerprogramma?

Berichtdoor Koepel » 26 Apr 2018, 16:42

De EEPROM.read() en EEPROM.write() lezen en schrijven een byte.
De EEPROM.get() en EEPROM.put() functies zijn er bij gekomen en werken op de EEPROMAnything manier. Je kunt dan een variabele die uit meerdere bytes bestaat lezen en schrijven.

Iets om de andere dag doen is lastig. Als je dat dagelijks een klein beetje kunt is het eenvoudiger.

Dat het Nextion scherm het niet altijd kan bijbenen is lastig voor me om daar iets over te zeggen. De Nextion Arduino library zit niet goed in elkaar (en ik ben niet de enige die dat vind).
Het wachten op de reactie van de Nextion zit verweven in die Nextion Arduino library. Dat is inderdaad uit te zetten, maar dan zul je zelf een Nextion library moeten gaan schrijven. Ik denk dat je het er mee zult moeten doen zoals het nu is.

Ik gebruik de Nextion Arduino library niet meer. Bij mij loopt alles soepel zonder delay en zonder te wachten. Dan blijkt dat het Nextion display zelf ook nog een vertraging heeft. Als ik heel veel en snel op een knopje op het scherm druk, dan komt dat met een vertraging binnen.

De calibratie is typisch iets om in EEPROM op te slaan. Bij het starten van de Arduino kunnen die dan ingelezen worden vanuit de EEPROM.

Berichten: 328
Geregistreerd: 23 Okt 2016, 20:29

Re: Eigen doseerprogramma?

Berichtdoor benvo » 26 Apr 2018, 18:41

De dingen die je hier opgenoemd hebt werken allemaal bij mij. Met uitzondering dus van het op de juiste tijd een pomp aanzetten, als eerder vertelt.
Je opperde om eend te kijken naar TimeAlarms. Dat heb ik dan ook gedaan. Om te begrijpen hoe zoiets werkt probeer ik dat dan vaak uit op de Serial Monitor. Ook in dit geval, bijvoorbeeld. TimeLib.h en TimeAlarms werken vaak, zo zag ik met een niet zo'n beste klok de DS1307. Daar is wel een oplossing voor nl. de DS3232.h library die naadloos samenwerkt met de eerstgenoemde library's. Graag laat ik een klein sketchje zien wat ik maar niet werkend krijg, het regent fouten. Ik vul e.e.a. in zoals aangegeven bij de TimeAlarms voorbeelden. Er wordt bijvoorbeeld gevraagd om "MorningAlarm" te declareren in deze scoop. Bij de voorbeelden, die werken wordt niet gedeclareerd. Een andere fout die ik ook niet kan verklaren staat op de regel void MorningAlarm(). "a function definition is not allowed here before '{' token". Maar waar ik die accolade dan zou moeten zetten? Ook hier is in de voorbeelden niets over te vinden. Als ik echter dit sketchje werkend krijg dan zou dat relatief gemakkelijk in m'n programma te passen zijn. Misschien zie jij het wel?


cpp code
Code: Alles selecteren

#include <TimeLib.h>
#include <TimeAlarms.h>
#include <DS3232RTC.h>
AlarmId id;

void setup()
{
  Serial.begin(9600);

  pinMode(13, OUTPUT);

  setSyncProvider(RTC.get);   // Get the time from the RTC
  /* if (timeStatus() != timeSet) {
     Serial.println("Unable to sync with the RTC");
    }
    else {
     Serial.println("RTC has set the system time");
    }/
    setTime(hour, minute, second, day, month, year)*/
  //setTime(17, 57, 0, 25, 4, 2018);

  Alarm.alarmRepeat(17, 58, 0, MorningAlarm);

}


void loop() {
 

  void MorningAlarm() {
    Serial.println("Alarm: - turn lights off");
  }
 
  char tijdString[9];
  sprintf(tijdString, "%02d:%02d:%02d", hour(), minute(), second());
  Serial.println(tijdString);

  Alarm.delay(1000);

  char datumString[9];
  sprintf(datumString, "%02d:%02d:%02d", day(), month(), year());
  Serial.println(datumString);

  Alarm.delay(1000);
}





Berichten: 328
Geregistreerd: 23 Okt 2016, 20:29

Re: Eigen doseerprogramma?

Berichtdoor benvo » 27 Apr 2018, 15:12

Het bovenstaande is opgelost.
Ik ga nu proberen TimeAlarms te integreren in mijn doseerprogramma.


Groet,
Ben.

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

Re: Eigen doseerprogramma?

Berichtdoor Koepel » 27 Apr 2018, 23:56

De functie die de TimeAlarms aanroept zou je ook een callback functie kunnen noemen, net als bij de Nextion callback functies.

Wanneer je op het scherm op een knop drukt dan kan zo'n functie aangeroepen worden.
Wanneer de TimeAlarms ziet dat het tijd is, dan kan zo'n functie aangeroepen worden.

Je had per ongeluk de "MorningAlarm()" binnen de loop() gedefinieerd.

Heb je dit gezien: https://github.com/JChristensen/DS3232RTC.
Die schijnt te werken met de RTClib en de syncprovider.

De DS3232 schijnt wat extra ram te hebben wat de DS3231 niet heeft.

Begrijp je wat er gebeurt ? De syncprovider synchroniseert de klok regelmatig met behulp van de RTC chip. De RTC chip geeft de datum en tijd en dat wordt omgezet naar het aantal seconden sinds 1970. Dat gebruikt de syncprovider functie. Vervolgens gaat de TimeLib dat weer omzetten naar datum en tijd.
Dat is dus best omslachtig. Een RTC chip die het aantal seconden sinds 1970 geeft zou veel eenvoudiger zijn.

Volgende

Terug naar Overige Software

Wie is er online?

Gebruikers in dit forum: Geen geregistreerde gebruikers en 2 gasten