hulp gevraagd voor arduino regelunit voor distilleer apparaat

Hoi ik zou graag een naaldkraan dicht willen zetten met een stappenmotor.
Nu is dit niet zo heel ingewikkeld.
Maar ik wil graag eerst de naaldkraan dichtdraaien "Homen"
Dan de teller op nul zetten zodat ik dan de aantal stappen aan kan geven om de naaldkraan op een bepaalde stand kan zetten.
Nu is het probleem dat de naaldkraan 5 hele slagen heeft van dicht naar open.
Ik wil een schakelaar of optische sensor gebruiken voor de stand "Home"
maar hoe weet de software dan of het bij de eerste of bv 3 slag van de kraan is ?
als bv de stroom is uitgevallen ?

graag jullie gedachten hierover,
Zodat ik rekening kan houden met het mechanisme om dit te bouwen.

mvg Rolf

Ik heb in het verleden de volgende techniek gebruikt
Als een stappenmotor te zwaar belast is draait hij niet en als je de stroom beperkt brand hij ook niet stuk.
Dus dan kan je gewoon lang genoeg dicht/open draaien en dan weet je dat hij dicht/open is.
Het enige wat je dan eventueel nog moet doen is de mechanische verbinding motor-kraan zo uitlijnen dat je precies op een stap dicht bent. Dit om te voorkomen dat spanning wegnemen van de motor de kraan eventueel een klein beetje opent.

Merk wel op dat een stappenmotor niet ideaal is om een kraan te bedienen. Een kraan die helemaal open of dicht is "plakt" en heeft dus een extra grote kracht nodig bij het beginnen openen/sluiten. Een stappen motor heeft niet meer kracht als hij "vertrekt", een gewone brushed DC motor heeft dat wel. Dus kies je motor maar sterk genoeg.

Homen is niets anders dan de controller vertellen waar een bepaald object zich in de ruimte bevind. Bij een liniare verplaatsing is dat meestal een schakelmoment. Dat hoeft niet een eind of begin punt te zijn.
Bij een 3D printer is dat voor de Z-as meestal een willekeurig punt. Vervolgens is het van belang te weten hoeveel stappen het is tot de nozzle het printbed raakt. Dit noemen we de offset. Om het schakelmoment te vinden zou ik de kraan vol open kant kiezen en met name een kwartslag voor maximaal zodat de kraan niet "klemt". Laten we op dit schakelmoment de variabele de waarde 0 geven. Vervolgens is het exact tellen tot de kraan geen vloeistof meer doorlaat. Dat hoeft niet per definitie helemaal dicht te zijn....... stel dat dit 832 stappen is. 832 is dan de maximale grootte van de variabele. je kan de stappenmotor nu precies vertellen wat je wil zolang je tussen deze waarden blijft. Het lijkt mij raadzaam of bij veel wijzigingen van de kraanstand af en toe te homen om te zien of er nergens een stap is gemist. dat doen stappenmotoren wel eens :smiley:

Hoi Rolf.

Gaat dit nog steeds om je destilleer apparaat, en gebruik je daar dan ook nog deze naaldkraan constructie voor:

In dat geval heb je nog de meerslagen potmeter die er bovenop zit, en waarmee je gemakkelijk die 3 slagen kunt meten.
Door de overbrenging met de snaar zal die gaan slippen als de kraan helemaal dicht staat, maar denk dat je dat niet te vaak wil doen vanwege slijtage die dat zal opleveren.

Hoi Mas,

Leuk dat je nog steeds zoveel op dit forum zit !!!
Ik denk dat jij toch aardig wat mensen hier op de goede weg brengt.
Inderdaad weer begonnen aan dit project.
Mijn andere projecten zijn klaar en werken naar behoren.
De hierboven geposte afbeelding is inderdaad waar het om gaat.
Ik ben gisteravond de hele avond aan het testen en meten gegaan.
En ben tot de conclusie gekomen om de naaldkraan te hergebruiken.
de keuze hiervoor is simpel de kraan kost geen kracht om open en dicht te draaien.
en bij het sluiten hoef je hem niet strak aan te draaien om hem volledig af te sluiten.
Wat weer handig is voor de stappenmotor dat deze geen kracht hoeft te leveren bij weer open draaien.
dus geen slip op het riempje idd.

Wel ben ik erachter gekomen dat de potmeter geen goede oplossing is voor wat ik er mee wil doen.
Omdat hij wat je al aangaf door warmte en slip op een gegeven moment gaat afwijken.
en dat het dan eindelijk niet betrouwbaar meer is en moeilijk is te "resetten'

Nu ben ik gisteren aan het experimenteren gegaan.
Ik ben tot de ontdekking gekomen dat de naaldkraan maar 1 slag open hoeft.
Voor waar ik hem voor nodig heb.
Dat is dus een hele opluchting omdat het hele verhaal met de potmeter niet meer gebruikt hoeft te worden.

Ik ga het nu maken op ongeveer dezelfde manier als hierboven.
de potmeter verdwijnt.
de grote poelie ga ik vervangen door een poelie en een groter schijf met een nok erop die
dan een microschakelaar bedient.
Dit word dan de home "trigger".
Bij het starten van het programma zet hij in de setup de kraan dicht tot de microschakelaar sluit.
Dit word dan de begin waarde.
En vandaar wil ik de stappen gaan tellen voor de positie van de kraan.
en zodra ik klaar ben met stoken en weer een nieuwe distillatie start
begint hij weer eerst met "homen"

ik heb eerst zitten denken om een andere stappenmotor te gebruiken .
Maar deze is eindelijk vrij klein en makkelijk te verkrijgen.
En voor beginners als ik overal in toe te passen.
wat weer mooi is om meer personen hiermee te laten werken.

Nu is de volgende stap het schrijven van een zo simpel mogelijk programma.

Maar ik zit nu eindelijk te denken om dit toch bij het andere draadje te zetten van mijn distileer apparaat

Is het op een of andere manier mogelijk om deze post daar onder toe te voegen ?

Ja dat kan.
Daarvoor moet je op het vlaggetje onder je 1e post in deze thread klikken en dan vertellen wat je wil doen waarbij je naar de betreffende thread linkt.
Daarmee wordt dan ook meteen die thread weer geopend als het goed is.
Ik zal dat zometeen na dit antwoord gelijk even doen en hoop dat de moderatoren dat zullen honoreren.

Voor wat betreft het slippen:
Als ik het goed zie, zit de potmeter door het grote wiel heen en meteen aan de hendel van je naaldkraan, en is de kans dat die zou gaan slippen bijna gelijk aan nul.
Op dat moment is een slippende motor helemaal niet meer interessant en zou de potmeter (aangenomen dat die verder stabiel functioneert) jou de exacte waarde van de opening van je kraan moeten geven.
De potmeter is gekoppeld met een bus en een aantal borgboutjes.
Wanneer je zo'n borgboutje vervangt door een langer exemplaar die een eind uitsteekt, kun je daar je eindschakelaar ook mee bedienen en hoef je je draaibank niet meer te gebruiken om een groter wiel te maken (alhoewel dat natuurlijk wel een mooi excuus is om je speelgoed weer eens uit te pakken natuurlijk).
Je moet in dat geval natuurlijk wel nog steeds een mooie beugel maken om je eindschakelaar aan te monteren (en wel zo dat je daar ook nog wat aan kunt instellen).

Ik heb je twee topics samengevoegd zoals gevraagd.

Hoi Perry bedankt hiervoor :+1:

Hoi mas,

De potmeter komt niet meer terug.
Alleen een schakelaar die bedient word als de kraan dicht is.
Dit word dan het startpunt (home en 0 voor de stappen)
de naaldkraan bediening word dus 1 slag van dicht naar open.
Ik wil hiervandaan veder gaan omdat dit gedeelte het moeilijks word voor mij.

Ik wil ook beginnen met het totale menu opnieuw op te bouwen.
Maar ik wil beginnen met een nieuw menu
Dat is handbediening.
Waarom dan kan ik eerst zorgen dat ik de naaldkraan kan beienen met de knoppen op mijn bediening.
dan kom ik eindelijk bijna alle basis stappen tegen die later makkelijker in een automatish programma zijn te zetten.

Ook wil ik even kijken of ik op de een of andere manier schemas toe kan voegen.
Met het toetsenbordje dat ik heb met de juiste weerstandwaardes
en de gebruikte onderdelen zoals lcd en schakelaars en dergelijke.
Zodat iemand die hier ook mee aan de gang wilt gaan weet wat hij nodig heeft
en weet hoe hij het een en ander aan moet sluiten.

1 Like

Zo de naaldkraan met homeswitch is klaar.
Ik heb hiervoor de : 28BYJ-48 stappenmotor voor gebruikt met de ULN2003 driver,
Deze is goed verkrijgbaar en voor deze toepassing goed te gebruiken.

Ik heb de volgende code gebruikt:



#include <AccelStepper.h>
#define HALFSTEP 8

// Motor pin definitions
#define motorPin1  8                         // IN1 on the ULN2003 driver 1
#define motorPin2  9                         // IN2 on the ULN2003 driver 1
#define motorPin3  10                       // IN3 on the ULN2003 driver 1
#define motorPin4  11                       // IN4 on the ULN2003 driver 1

// gebruik deze volgorde IN1-IN3-IN2-IN4 voor gebruik met  AccelStepper met 28BYJ-48 stappenmotor
AccelStepper stepper1 (HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);

void setup() {
  stepper1.setMaxSpeed(1000.0);
  stepper1.setAcceleration(300);
  stepper1.setSpeed(300);
  stepper1.moveTo(20000);                  // laat de stappenmotor STRAKS 20000 stappen nemen

   stepper1.run();
   
 }                                                               // einde setup

void loop() {

  
  
   }                                                            //einde loop
  

Als ik nu de code upload naar mijn arduino uno doet hij niets ?
Wel als ik" stepper1.run(); " in de void loop zet.
gaat hij netjes de 20000 stappen lopen en stopt hij.

Maar ik wil dit dadelijk graag gaan doen in de setup.
Zodat hij dit maar 1 keer doet met opstarten.

Ik heb voor de homeschakelaar een micro schakelaar gebruikt.
en deze word "Close" als de kraan in de positie dicht staat.
hij is op de digitale pin 4 aangesloten op het arduino bordje.

Kan merken dat ik weer een tijdje uit het programmeren ben.
moet het weer een beetje eigen maken haha,
Heb al het een en ander geprobeerd om de schakelaar toe te voegen in de code.
zodat de stappenmotor stopt bij bekrachtigen van de schakelaar.

Ga nu even kijken hoe ik een afbeelding kan toevoegen van de naaldkraan met stappenmotor en homeschakelaar.

Ah gelukt :sweat_smile:


Zo weer een stukje veder ik heb een zo kort mogelijke code gemaakt.
Die laat de stappenmotor draaien tot de microschakelaar word bediend.
ik heb ook een serial print toegevoegd om de staat van de schakelaar te controleren in de seriele monitor.

Ik krijg het echter niet voor elkaar om dit stukje code 1 keer te laten uitvoeren in de setup.
en dan de steps op 0 te zetten voor de rest van het programma.
Alleen zoals in de code hieronder in de "loop "
Iemand een idee om me in de goede richting te sturen ?



  #include <AccelStepper.h>
  #define HALFSTEP 8

  // Motor pin definitions
  #define motorPin1  8                      // IN1 on the ULN2003 driver 1
  #define motorPin2  9                      // IN2 on the ULN2003 driver 1
  #define motorPin3  10                     // IN3 on the ULN2003 driver 1
  #define motorPin4  11                     // IN4 on the ULN2003 driver 1

            // gebruik deze volgorde IN1-IN3-IN2-IN4 voor gebruik met  AccelStepper met 28BYJ-48 stappenmotor
  AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);

  #define home_switch 4                     // Pin 4 connected to Home Switch (MicroSwitch)
  //int steps;                              // Used to set HOME position after Homing is completed

void setup() {
  
  stepper1.setMaxSpeed(1000.0);
  stepper1.setAcceleration(300);
  stepper1.setSpeed(400);
  stepper1.moveTo(20000);                   // laat de stappenmotor STRAKS 20000 stappen nemen
  
  Serial.begin(9600);                       //start serial connection
  pinMode(4, INPUT_PULLUP);                 //configure pin 4 as an input and enable the internal pull-up resistor
 
  }                                         //einde setup  

void loop() {

   int sensorVal = digitalRead(4);          //read the pushbutton value into a variable
   Serial.println(sensorVal);               //print out the value of the pushbutton seriele monitor
   if (sensorVal == HIGH) {                 //if sensorval = 1
    stepper1.run();                         //start de stappenmotor
  } else {                                  //anders
    //stepper1.stop();                      //stop de stappenmotor
    stepper1.disableOutputs();              //deze is hier beter zet de uitgangen uit anders word de stappenmotor warm
    
  } 
  
  }                                         //einde loop
  

Zo na een paar avonden stoeien met google en de codes heb ik het voor elkaar.
De naaldkraan gaat netjes dicht tot aan de schakelaar.
Dan gaat hij langzaam wat stapjes open tot de schakelaar weer open is.
Dit word dan de beginstand van de naaldkraan.

Nu wil ik dadelijk de up en de down knop op mijn bediening display
gaan gebruiken om de naaldkraan te kunnen bedienen.

Ik wil dit ook weergeven op het display (4x20 lcd)
dicht is 0 en volledig open 20

dus ik wil hiervoor 20 stappen gebruiken.
nu eens gaan bedenken hoe ik dit in een code moet toevoegen.
Iemand die hierover wilt meedenken ?

en de code tot nu toe voor het homen van de naaldkraan.
Hoop dat ik hier meerdere personen mee kan helpen
voor hun projecten

gr Rolf

//  Naaldkraan Homing code using AccelStepper voor distileer apparaat



#include "AccelStepper.h" 
#define HALFSTEP 8

// Motor pin definitions
#define motorPin1  8                        // IN1 on the ULN2003 driver 1
#define motorPin2  9                        // IN2 on the ULN2003 driver 1
#define motorPin3  10                       // IN3 on the ULN2003 driver 1
#define motorPin4  11                       // IN4 on the ULN2003 driver 1

                                            // gebruik deze volgorde IN1-IN3-IN2-IN4 voor gebruik met  AccelStepper met 28BYJ-48 stappenmotor
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);

#define home_switch 4                       // Geeft aan dat Pin 4 verbonden is met de microschakelaar
                                            // Stepper Travel Variables
long TravelX;                               // Used to store the X value entered in the Serial Monitor
int move_finished=1;                        // Controleerd of move is voltooid
long initial_homing=-1;                     // Used to Home Stepper at startup

void setup() {
   Serial.begin(9600);                      // Start the Serial monitor with speed of 9600 Bauds
   
   pinMode(home_switch, INPUT_PULLUP);
   
                                           // Set Max Speed and Acceleration of each Steppers at startup for homing
  stepper1.setMaxSpeed(300.0);             // Set Max Speed of Stepper (Slower to get better accuracy)
  stepper1.setAcceleration(300.0);         // Set Acceleration of Stepper
 
                                           // Start Homing procedure of Stepper Motor at startup

  while (digitalRead(home_switch)) {       // Make the Stepper move CW until the switch is activated   
    stepper1.moveTo(initial_homing);       // Set the position to move to
    initial_homing++;                      // Decrease by 1 for next move if needed
    stepper1.run();                        // Start moving the stepper
    delay(5);
  }

  stepper1.setCurrentPosition(0);          // Set the current position as zero for now
  stepper1.setMaxSpeed(75.0);              // Set Max Speed of Stepper (Slower to get better accuracy)
  stepper1.setAcceleration(75.0);          // Set Acceleration of Stepper
  initial_homing=1;

  while (!digitalRead(home_switch)) {      // Make the Stepper move CCW until the switch is deactivated
    stepper1.moveTo(initial_homing);  
    stepper1.run();
    initial_homing--;
    delay(5);
  }
  
  stepper1.setCurrentPosition(0);
  stepper1.setMaxSpeed(1000.0);            // Set Max Speed of Stepper (Faster for regular movements)
  stepper1.setAcceleration(1000.0);        // Set Acceleration of Stepper

  }


void loop() {

 while (Serial.available()>0)  { // Check if values are available in the Serial Buffer
 move_finished=0;  // Set variable for checking move of the Stepper
  
 }}

ik heb de code weer wat aangepast zodat hij aangeeft op een 4x20 lcd display
welke stap hij zet.
Alleen merk ik nu dat de stappenmotor erg traag loopt.
Als ik het stukje van het neerzetten van de tekst en de stand weghaal.
Gaat hij wel de ingestelde snelheid halen.
Komt dit omdat hij de tekst neerzet dan een stap dan weer de tekst en dan weer een stap ?
Als ik de stap weghaal set current position doet hij het nog.
Dus hij doet het echt op het stukje tekst neerzetten en dan weer een stap.
Of zie ik iets over het hoofd ?

//  Naaldkraan Homing code using AccelStepper voor distileer apparaat

//////////////////////// DISPLAY ////////////////////////////////
#include <Wire.h> // Library for I2C communication
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h> // include i/o class header
#include <AccelStepper.h>
 hd44780_I2Cexp lcd; 
 
/////////////////////// STAPPEN MOTOR //////////////////////////


#include "AccelStepper.h" 
#define HALFSTEP 8
#define motorPin1  8                        // IN1 on the ULN2003 driver 1
#define motorPin2  9                        // IN2 on the ULN2003 driver 1
#define motorPin3  10                       // IN3 on the ULN2003 driver 1
#define motorPin4  11                       // IN4 on the ULN2003 driver 1

                                            // gebruik deze volgorde IN1-IN3-IN2-IN4 voor gebruik met  AccelStepper met 28BYJ-48 stappenmotor
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);

#define home_switch 4                       // Geeft aan dat Pin 4 verbonden is met de microschakelaar
                                            // Stepper Travel Variables
long TravelX;                               // Used to store the X value entered in the Serial Monitor
int move_finished=1;                        // Controleerd of move is voltooid
long initial_homing=-1;                     // Used to Home Stepper at startup

/////////////////////////////////////////// SETUP /////////////////////////////////////
void setup() {
   Serial.begin(9600);                      // Start the Serial monitor with speed of 9600 Bauds

  lcd.begin(20, 4);
  lcd.init();                      // initialize the lcd //lcd.begin(20, 4);   // geeft aan dat het om een 20x4 lcd gaat.
  lcd.backlight();
  lcd.clear();                                                        // maakt het lcd scherm leeg.
   
   pinMode(home_switch, INPUT_PULLUP);
   
                                           // Set Max Speed and Acceleration of each Steppers at startup for homing
  stepper1.setMaxSpeed(400.0);             // Set Max Speed of Stepper (Slower to get better accuracy)
  stepper1.setAcceleration(400.0);         // Set Acceleration of Stepper
 
                                           // Start Homing procedure of Stepper Motor at startup

  while (digitalRead(home_switch)) {       // Make the Stepper move CW until the switch is activated   
    stepper1.moveTo(initial_homing);       // Set the position to move to
    initial_homing++;                      // Decrease by 1 for next move if needed
    stepper1.run();                        // Start moving the stepper
    
  }

  stepper1.setCurrentPosition(0);          // Set the current position as zero for now
  stepper1.setMaxSpeed(75.0);              // Set Max Speed of Stepper (Slower to get better accuracy)
  stepper1.setAcceleration(75.0);          // Set Acceleration of Stepper
  initial_homing=1;

  while (!digitalRead(home_switch)) {      // Make the Stepper move CCW until the switch is deactivated
    stepper1.moveTo(initial_homing);  
    stepper1.run();
    initial_homing--;

  }
  stepper1.disableOutputs();              //deze is hier beter zet de uitgangen uit anders word de stappenmotor warm
  stepper1.setCurrentPosition(0);
 

  }


void loop() {

 //while (Serial.available()>0)  {           // Check if values are available in the Serial Buffer
// move_finished=0;                          // Set variable for checking move of the Stepper
 stepper1.setMaxSpeed(600.0);
 stepper1.setAcceleration(600.0);
 stepper1.moveTo(-10800);
 
 stepper1.run(); 
 
  lcd.setCursor(0,1);                      // zet de cursor neer op rij 2 op positie 1.
  lcd.print("STAP:       ");               // zet tekst neer "STAP:    "
  lcd.setCursor(6,1);                      // zet de cursor neer op rij 2 op positie 1.
  lcd.print(stepper1.currentPosition());              // zet tekst neer "STAP:    "
  lcd.setCursor(0,2);                      // Zet de cursor neer op rij 3 op positie 1.
  lcd.print("NAALDKRAAN:");                // Zet tekst neer "NAALDKRAAN:    ".

 
 }

 

Het gaat om het stukje in de loop.

Hoi homedistiller.

Jouw analyse klopt; door het printen naar je scherm gaat er relatief veel tijd verloren.
Ik denk dat ik je een tijd geleden al eens had laten zien dat je wanneer je naar je scherm schrijft, het niet slim is om telkens hetzelfde te schrijven.
Het is veel beter om 1 keer de inhoud van je scherm te vullen en daarna alleen dat te veranderen dat ook gewijzigd is.
Dus alleen de cursor op de juiste positie zetten, en dan de veranderde waarde uit currentPosition schrijven.
Dat scheelt 2/3 van je handelingen naar het scherm.
Wanneer je voor het printen van de nieuwe waarde, nog steeds eerst de oude waarde wil wissen dan is het slimmer om alleen die oude waarde te overschrijven en niet de "STAP: " die daarvoor al staat nog een keer te schrijven.
Dat scheelt je dan ook weer de helft van de tijd die voor die handeling nodig is.

Verder kun je er ook voor kiezen om niet elke stap af te drukken.
Daardoor zul je veel snelheid terugwinnen, en er is maar een heel kleine kans dat iemand elke stap wil zien.
Je kunt bijvoorbeeld een keer voor (zoals je nu al doet), en een keer na het printen stepper.run() aan te roepen.
Dan gaat ie al 2 keer zo snel.
Of eens per 10 stappen, plus nog een laatste keer na het behalen van de eindwaarde (zodat je niet onverhoopt op een onjuiste waarde uitkomt).

Experimenteer er eens mee zou ik zeggen.

Zo weer een stuk veder.
het is me gelukt om de stappenmotor netjes te homen.
Hij gaat nu terug tot de microschakelaar bedient word.
Dan gaat hij langzaam weer iets terug tot de microschakelaar weer onderbroken is en stopt dan netjes en zet de stappen op nul.
Ik heb het nu in mijn menu toegepast.
Ik gebruik nu zoals ik aangaf het handbediend menu.
Dit om dadelijk handmatig een paar stoken te doen.
Om te kijken welke openingen ik wil hebben van de naaldkraan,
en dit dan om te zetten in 20 stappen
0 = dicht
20 = 1 volledige slag open.
ook heb ik 3 temperatuursensors toegevoegd.
en de tekst opening hier achter wil ik 0 tot 20 weergeven.





als het laatste scherm word weergegeven zie laatste foto.
Wordt de solid state relay aangezet zodat de verwarmingsspiraal aangaat om de vloeistof te verwarmen,
vandaar ook eerst de vraag is de ketel gevuld ?
anders zou het element verbranden.

/*
TOT NU TOE GEDAAN:
1 menu opgebouwd (Handbediening,Puur Distilleren,Pot Distilleren,
  Alleen Handbediening is nu in gebruik. de rest is nog leeg.
  Na de vraag van Is de ketel gevuld word de SSR aangezet door pin 13 op hoog te zetten.
  Dit is er voor dat het element niet verbrand als er geen vloeistof aanwezig is.
  Begonnen met het menu op te bouwen Handbediend.
  3 temp sensors toegevoegd
  opmerking nog doen
  eerst het scherm wissen dan naar volgend menu gaan.
  Anders knippert het beeld zie is er een vloeistof in de ketel dat nog veranderen.
  
*/

#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 6                                                         // one wire op ingang 6
#include <Wire.h> // Library for I2C communication
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h> // include i/o class header
#include <AccelStepper.h>
#include <Adafruit_BMP085.h>                                                   // Adafruit BMP085 library
#define HALFSTEP 8


hd44780_I2Cexp lcd;                                                            // declare lcd object: auto locate & config display for hd44780 chip
OneWire oneWire(ONE_WIRE_BUS);                                                 // Pass address of our oneWire instance to Dallas Temperature. 
DallasTemperature sensors(&oneWire);                                           // dallas temp op onewire

DeviceAddress Probe01 = { 0x28, 0x78, 0x9D, 0xCA, 0x04, 0x00, 0x00, 0xC0 };    // Interne adres van ds18b20 probe 1
DeviceAddress Probe02 = { 0x28, 0x6C, 0x74, 0xCB, 0x04, 0x00, 0x00, 0xE1 };    // Interne adres van ds18b20 probe 2
DeviceAddress Probe03 = { 0x28, 0x2C, 0x09, 0x01, 0x05, 0x00, 0x00, 0x9C };    // Interne adres van ds18b20 probe 3

float Tin;
float Tkw;
float Temp;

float readPressure;                                                            //luchtdruk
float  EtOH;

Adafruit_BMP085 bmp;

int Min=10; 
int Sec=10;

long previousMillis = 0;
long interval = 999;

int Tekst;
int OPWARMEN;
int relay =10;
int ssr = 13;                                                          // Hier word ssr aangemaakt voor de solit state relay op digitale uitgang 9
int adc_key_val[5] ={50, 200, 400, 600, 800 };                         // Ingangs waarden van mijn toetsen.
int mm = 1;                                                            // Zet menu mode op 1.
int NUM_KEYS = 5;                                                      // geeft volgens mij aan het aantal knoppen dat er gebruikt word voor input. >> Klopt, en is nodig voor het tellen straks
int adc_key_in;  
int key=-1;                                                            // Vult alvast een toetswaarde in; -1 betekent nog geen toets gedrukt.
int KeyDet=-1;                                                         // Houd bij dat er een toets druk geregistreerd werd .
int oldkey=-1;                                                         // Houd bij welke toets het laatst gedrukt werd.
int i=0;                                                               // i word gebruikt als teller later, moet bij 0 beginnen inplaats van 1
int Pijl=126;                                                          // code voor de "pijl" symbool
int Item = 1;                                                          // Zet menu item op de eerste, zodat dit na een reset al goed staat
int x=0;                                                               // x coordinaat voor setCursor.
int y=0;                                                               // y coordinaat voor setCursor.
float nieuwWaarde;                                                     // Gebruiken float omdat we met variable willen werken met achter de punt bv: 78.50
float oudWaarde;
float TempV=78.5;                                                      // Hier word TempV niet alleen aangemaakt, maar ook gelijk met een beginwaarde gevuld
float TempE=99.00;                                                     // Hier word TempE niet alleen aangemaakt, maar ook gelijk met een beginwaarde gevuld
float TempT=00.30;
int Stijd=15;
int nieuwTijd;
int oudTijd;
const int Rechts=0;
const int Omlaag=2;
const int Omhoog=1;
const int Esc =3;
const int OK=4;

  #include <AccelStepper.h>
  #define HALFSTEP 8

  // Motor pin definitions
  #define motorPin1  8                      // IN1 on the ULN2003 driver 1
  #define motorPin2  9                      // IN2 on the ULN2003 driver 1
  #define motorPin3  10                     // IN3 on the ULN2003 driver 1
  #define motorPin4  11                     // IN4 on the ULN2003 driver 1

            
  AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);   // gebruik deze volgorde IN1-IN3-IN2-IN4 voor gebruik met  AccelStepper met 28BYJ-48 stappenmotor

  #define home_switch 4                     //  digital Pin 4 connected to Home Switch (MicroSwitch)
  
  int move_finished=1;                     // Used to check if move is completed
  long initial_homing=-1;                  // Used to Home Stepper at startup

//////////////////////////////////////////////////////////////// setup ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void setup()
{                                                                     // Begin setup // Begin setup deze doorloopt hij alleen bij opstarten of reset

Serial.begin(9600);                                                   // opent de seriele poort en zet data verkeer op 9600 bps.
 sensors.begin(); 
 sensors.setResolution(Probe01, 12);                                  // Zet de resolutie op 12 bit (kan zijn 9 to 12 .. lager is sneller)
 sensors.setResolution(Probe02, 12);                                  // Zet de resolutie op 12 bit (kan zijn 9 to 12 .. lager is sneller)
 sensors.setResolution(Probe03, 12);                                  // Zet de resolutie op 12 bit (kan zijn 9 to 12 .. lager is sneller)
 pinMode(ssr, OUTPUT);                                                // Hier maakt hij een digitale uitgang van ssr digitale pen 13 dus 
 digitalWrite (ssr, LOW);                                             // Hier maak ik digitaal pen 13 laag. zodat ssr relay uitstaat voor beveiliging verwarmingselement 
 pinMode(relay,OUTPUT);

  
    
   

  

  lcd.begin(20, 4);                                                   // geeft aan dat het om een 20x4 lcd gaat.
  lcd.init();                                                         
  lcd.backlight();
  lcd.clear();                                                        // maakt het lcd scherm leeg.
  
  lcd.setCursor(0,0);                                                 // zet de cursor neer op rij 1 op positie 1.
  lcd.print("       WELKOM");                                         // zet tekst neer "WELKOM"
  delay (1000);                                                       // wacht 1 sec. 
                                                         
  lcd.setCursor(0,1);                                                 // Zet de cursor neer op rij 2 op positie 1.
  lcd.print("  VEEL PLEZIER MET");                                    // Zet tekst neer "VEEL PLEZIER MET".
  delay (1000);                                                       // wacht 1 sec.
  
  lcd.setCursor(0,2);                                                 // Zet de cursor neer op rij 3 op positie 1.
  lcd.print("    DISTILLEREN!");                                      // Zet tekst neer "DISTILLEREN!".
  delay (1000);                                                       // Wacht 1 sec.
  
  lcd.clear();                                                        // Maakt het lcd scherm weer leeg.
  lcd.setCursor(0,1);                                                 // Zet de cursor op rij 2 positie 1.
  lcd.print("  AUTOMATIC STILL!");                                    // Zet tekst neer "AUTOMATIC STILL!".

  lcd.setCursor(0,2);                                                 // Zet de cursor neer op rij 3 op positie 1.
  lcd.print("    ROLF KOEDAM");                                       // Zet tekst neer "Rolf Koedam".
  delay (2000);                                                       // Wacht 2 sec.

   ////////////////////////////////////////////////////////////// Homing ///////////////////////////////////////////////////////////////

  pinMode(home_switch, INPUT_PULLUP);
                                                                      // Set Max Speed and Acceleration of each Steppers at startup for homing
  stepper1.setMaxSpeed(300.0);                                        // Set Max Speed of Stepper (Slower to get better accuracy)
  stepper1.setAcceleration(300.0);                                    // Set Acceleration of Stepper

  lcd.clear();                                                        // Maakt het lcd scherm weer leeg.
  lcd.setCursor(0,2);                                                 // Zet de cursor neer op rij 3 op positie 1.
  lcd.print(" NAALDKRAAN HOMING.");                                   // Zet tekst neer " NAALDKRAAN HOMING.".
  while (digitalRead(home_switch)) {                                  // Make the Stepper move CW until the switch is activated   
    stepper1.moveTo(initial_homing);                                  // Set the position to move to
    initial_homing++;                                                 // Decrease by 1 for next move if needed
    stepper1.run();                                                   // Start moving the stepper
  delay(2);
}
  
  stepper1.setCurrentPosition(0);                                     // Set the current position as zero for now
  stepper1.setMaxSpeed(100.0);                                        // Set Max Speed of Stepper (Slower to get better accuracy)
  stepper1.setAcceleration(100.0);                                    // Set Acceleration of Stepper
  initial_homing=1;

  while (!digitalRead(home_switch)) {                                 // Make the Stepper move CCW until the switch is deactivated
    stepper1.moveTo(initial_homing);  
    stepper1.run();
    initial_homing--;
    delay(1);
  }
  
  stepper1.setCurrentPosition(0);
  lcd.clear();                                                        // Maakt het lcd scherm weer leeg.
  lcd.setCursor(0,2);                                                 // Zet de cursor neer op rij 3 op positie 1.
  lcd.print("  HOMING KOMPLEET!");                                    // Zet tekst neer "  HOMING KOMPLEET!".
  stepper1.setMaxSpeed(1000.0);                                       // Set Max Speed of Stepper (Faster for regular movements)
  stepper1.setAcceleration(1000.0);                                   // Set Acceleration of Stepper
  

  
  
  delay (2000);                                                       // Wacht 1 sec.
  lcd.clear();                                                        // Maakt het lcd scherm weer leeg.
  lcd.setCursor(0,1);                                                 // Zet de cursor op rij 4 op positie 1.
  lcd.print("  VERSIE. 25-07-21 ");
  lcd.setCursor(0,2);                                                 // Zet de cursor op rij 4 op positie 1.
  lcd.print("     Press<OK>");
  }                                                                   // Eind Setup // << Sluit de setup af.
  
   ////////////////////////////////////////////////////////////// LOOP //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  void loop()                                                        // Hier begint het hoofdprogramma te lopen.
  {                                                                  // Begin void loop //
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > interval) 
     previousMillis  = currentMillis;
    
  key = (analogRead (0));                                            // lees analoge ingang op pin 0
  if (key != oldkey)                                                 // Waneer een druktoets word gebruikt  "!=" betekent niet gelijk
  delay(50);                                                         // Wacht voor 0,05 sec
  adc_key_in = analogRead(0);                                        // Lees de waarde op de analoge ingang 0
  key = get_key(adc_key_in);                                         // Zet deze waarde in een toets om
  if (key != oldkey)                                                 // Wanneer de toets anders is als de laatste keer (dit werd eerder ook al gecontroleerd, maar kan geen kwaad)
  {                                                                  // 2  
  KeyDet = 1;                                                        // We hebben een geldige toetsdruk gezien 
  oldkey = key;
  }                                                                  // -- Sluit != oldkey -- 
  else KeyDet = 0;                                                   // toetswaarde is dezelfde als de vorige keer, dus er is geen nieuwe toets gedrukt

  if ((mm==1)&&(key ==OK))                                           // Waneer toets 4 "OK" gedetecteerd werd en menu is 1
  {                                                                  // 3    
  KeyDet = 0;
  mm = 2;                                                            // ga naar menu 2
  lcd.clear();                                                       // maak het lcd scherm leeg oftewel wis het vorige menu
  }                                                                  // Einde 3; Deze stond eerst verderop maar hier past ie beter 
  

  //////////////////////////////////////////////////////////////// MENU 2  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  if (mm ==2)                                                        // Zitten we in menu 2 ?
  {                                                                  // 1       We gaan het menu afbeelden
    lcd.clear();                                                     // Wis het display zodat we klaar zijn voor het normale scherm
    lcd.setCursor(0,0);                                              // Ik ben er niet helemaal zeker van dat we die cursor echt al terug moeten zetten
    lcd.print("1)    -MENU-");  
    lcd.setCursor(1,1);                                              // Tweede regel, tweede positie
    lcd.print("   HANDBEDIENING ");
    lcd.setCursor(0,3);                                              // Derde regel, tweede positie
    lcd.print("        <+/->   <OK>");
    mm = 3;                                                          // Het menu is gemaakt, nu gaan we naar de volgende stap, namelijk bediening ervan
  }                                                                  // Sluit MM 2; het menu is gemaakt
   if (mm ==3) 
  {
  if (KeyDet){                                                       // Het volgende word uitgevoerd omdat we een nieuwe toets hebben gezien, anders overgeslagen
  KeyDet = 0;                                                        // We gaan nu een nieuwe toetsdruk verwerken, dus deze nieuwe toetsdruk kan nu als eerste gewist worden zodat we niets dubbel doen 
  if (key ==OK) {                                                    // Waneer toets (4) OK werd geduwd
  Item = 1;                                                          // Zet Item terug, anders zouden we per ongeluk het menu de voelgnde keer op de verkeerde plaats binnenkomen en er gelijk weer uit raken voor we er goed en wel in zijn.
  mm = 12;                                                           // Zet menu mode terug zodat we het volgende "rondje" het menu hebben verlaten
  key = -1;                                                          // Wis key waarde ( -1 is geen key geregistreerd) zodat ie niet de volgende ronde nog blijft hangen.
        }                                                            // Sluit Instellingen OK
                                                                     // Einde 3; Deze stond eerst verderop maar hier past ie beter 
  if (key ==Omlaag)                                                  // Wanneer Omlaag gedetecteerd werd ga dan naar menu 2
  {                                                                  // 3.b    
  mm = 4;                                                            // zie hierboven: ga naar menu modus 8
  }                                                                  // Einde 3.b 
    }                                                                // -- Sluit KeyDet --
                                                                     // -- Sluit mm 5 --
  }

   /////////////////////////////////////////////////////////////// MENU 3 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
   if (mm ==4)                                                       // Zitten we in menu mode 8 ?
   {                                                                 // We gaan het menu afbeelden
      lcd.clear();                                                   // Wis het display zodat we klaar zijn voor het normale scherm
      lcd.setCursor(0,0);                                            // Ik ben er niet helemaal zeker van dat we die cursor echt al terug moeten zetten
      lcd.print("2)    -MENU-");   
      lcd.setCursor(1,1);                                            // Tweede regel, tweede positie
      lcd.print(" PUUR DISTILLEREN");

      lcd.setCursor(0,3);                                            // Derde regel, tweede positie
      lcd.print("        <+/->   <OK>");
      mm = 5;                                                        // Het menu is gemaakt, nu gaan we naar de volgende stap, namelijk bediening ervan
    }                                                                // Sluit MM 8; het menu is gemaakt
    if (mm ==5) 
    {
    if (KeyDet){                                                     // Het volgende word uitgevoerd omdat we een nieuwe toets hebben gezien, anders overgeslagen
      KeyDet = 0;                                                    // We gaan nu een nieuwe toetsdruk verwerken, dus deze nieuwe toetsdruk kan nu als eerste gewist worden zodat we niets dubbel doen 
   // if (key ==OK) {                                                // Waneer toets (4) OK werd geduwd
   //   Item = 1;                                                    // Zet Item terug, anders zouden we per ongeluk het menu de voelgnde keer op de verkeerde plaats binnenkomen en er gelijk weer uit raken voor we er goed en wel in zijn.
   // mm = 30;                                                       // Zet menu mode terug zodat we het volgende "rondje" het menu hebben verlaten
   //key = -1;                                                       // Wis key waarde ( -1 is geen key geregistreerd) zodat ie niet de volgende ronde nog blijft hangen.
   //}                                                               // Sluit Instellingen OK
  if (key ==Omlaag)                                                  // Wanneer Omlaag gedetecteerd werd ga dan naar menu 10
 {                                                                   // 7.b    
  mm = 6;                                                            // zie hierboven: ga naar menu modus 12
  }                                                                  // Einde 7.b 
  if (key ==Omhoog)                                                  // Waneer toets 1 "omhoog" gedetecteerd werd ga dan naar menu 4
  {                                                                  // 8    
  mm = 2;                                                            // zie hierboven: ga naar menu modus 4
  lcd.clear();                                                       // maak het lcd scherm leeg oftewel wis het vorige menu
  }                                                                  // Einde 8; Deze stond eerst verderop maar hier past ie beter 
    }                                                                // -- Sluit KeyDet --
  }                                                                  // -- Sluit mm 9 --



     /////////////////////////////////////////////////////////////// MENU 4 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 if (mm ==6)                                                         // Zitten we in menu mode 8 ?
  {                                                                  // We gaan het menu afbeelden
    lcd.clear();                                                     // Wis het display zodat we klaar zijn voor het normale scherm
    lcd.setCursor(0,0);                                              // Ik ben er niet helemaal zeker van dat we die cursor echt al terug moeten zetten
    lcd.print("3)    -MENU-");   
    lcd.setCursor(1,1);                                              // Tweede regel, tweede positie
    lcd.print(" POT DISTILLEREN");
    lcd.setCursor(0,3);                                              // Derde regel, tweede positie
    lcd.print("        <+/->   <OK>");
    mm = 7;                                                          // Het menu is gemaakt, nu gaan we naar de volgende stap, namelijk bediening ervan
  }                                                                  // Sluit MM 8; het menu is gemaakt
  if (mm ==7) 
  {
  if (KeyDet){                                                       // Het volgende word uitgevoerd omdat we een nieuwe toets hebben gezien, anders overgeslagen
  KeyDet = 0;                                                        // We gaan nu een nieuwe toetsdruk verwerken, dus deze nieuwe toetsdruk kan nu als eerste gewist worden zodat we niets dubbel doen    if (key ==OK) {                                                   // Waneer toets (4) OK werd geduwd
  //Item = 1;                                                        // Zet Item terug, anders zouden we per ongeluk het menu de voelgnde keer op de verkeerde plaats binnenkomen en er gelijk weer uit raken voor we er goed en wel in zijn.
  //mm = 40;                                                         // Zet menu mode terug zodat we het volgende "rondje" het menu hebben verlaten
 // key = -1;                                                        // Wis key waarde ( -1 is geen key geregistreerd) zodat ie niet de volgende ronde nog blijft hangen.
     //  }                                                           // Sluit Instellingen OK
  
                                                                     // Einde 7.b 
  if (key ==Omhoog)                                                  // Waneer toets 1 "omhoog" gedetecteerd werd ga dan naar menu 4
  {                                                                  // 8    
  mm = 4;                                                            // zie hierboven: ga naar menu modus 4
  lcd.clear();                                                       // maak het lcd scherm leeg oftewel wis het vorige menu
                                                                     // Einde 8; Deze stond eerst verderop maar hier past ie beter 
  }                                                                  // -- Sluit KeyDet --
  }
  }
  
      

  //////////////////////////////////////////////////////////////// MENU 4  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  if (mm ==12)                                                       // Zitten we in menu mode 4 ?
  {                                                                  // We gaan het menu afbeelden
    lcd.clear();                                                     // Wis het display zodat we klaar zijn voor het normale scherm
    lcd.setCursor(0,0);                                              // Ik ben er niet helemaal zeker van dat we die cursor echt al terug moeten zetten
    lcd.print("    !! LET OP !! ");  
    lcd.setCursor(1,1);                                              // Tweede regel, tweede positie
    lcd.print("IS DE KETEL GEVULD?");
    lcd.setCursor(0,3);                                              // Derde regel, tweede positie
    lcd.print("<Esc>           <OK>");
    mm = 13;                                                         // Het menu is gemaakt, nu gaan we naar de volgende stap, namelijk bediening ervan
  }                                                                  // Sluit MM 4; het menu is gemaakt
  if (mm ==13) 
  {
  if (KeyDet){                                                       // Het volgende word uitgevoerd omdat we een nieuwe toets hebben gezien, anders overgeslagen
  KeyDet = 0;                                                        // We gaan nu een nieuwe toetsdruk verwerken, dus deze nieuwe toetsdruk kan nu als eerste gewist worden zodat we niets dubbel doen 
  if (key ==OK) {                                                    // Waneer toets (4) OK werd geduwd
  Item = 1;                                                          // Zet Item terug, anders zouden we per ongeluk het menu de voelgnde keer op de verkeerde plaats binnenkomen en er gelijk weer uit raken voor we er goed en wel in zijn.
  mm = 15;                                                           // Zet menu mode terug zodat we het volgende "rondje" het menu hebben verlaten
  key = -1;                                                          // Wis key waarde ( -1 is geen key geregistreerd) zodat ie niet de volgende ronde nog blijft hangen.
  lcd.clear();
        }                                                            // Sluit Instellingen OK
  if (key ==Esc)                                                     // Waneer toets 3 "Esc" gedetecteerd werd ga dan naar menu 2
  {                                                                  // 3    
  mm = 2;                                                            // zie hierboven: ga naar menu modus 2
                                                                     // maak het lcd scherm leeg oftewel wis het vorige menu
  }                                                                  // Einde 3; Deze stond eerst verderop maar hier past ie beter 
                                                                     // Einde 3.b 
    }                                                                // -- Sluit KeyDet --
  }                                                                  // -- Sluit mm 5 --  

  
 //////////////////////////////////////////////////////////////// MENU 4  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  if (mm ==15)                                                       // Zitten we in menu mode 4 ?
  {                                                                  // We gaan het menu afbeelden
                                                                     // Zend een commando om de temperatuuren te krijgen
    digitalWrite (ssr, HIGH);
  //  EtOH = (bmp.readPressure()/ 1013 * 78.1 / 100);
     sensors.requestTemperatures();  
     
    Tin = sensors.getTempC(Probe01);
    Tkw = sensors.getTempC(Probe02);
    Temp = sensors.getTempC(Probe03); 

    
   // lcd.clear();                                                  // Wis het display zodat we klaar zijn voor het normale scherm
    lcd.setCursor(0,0);                                             // Tweede regel, tweede positie
    lcd.print("Temp.Uit:");
    lcd.print(Temp);                                                // Zet de variable Temp neer
    lcd.setCursor(0,1);                                             // Derde regel, tweede positie
    lcd.print("Temp.in: ");
    lcd.print(Tin);                                                 // Zet de variable Tin neer
    lcd.setCursor(0,2);                                             // Derde regel, tweede positie
    lcd.print("Temp.Kw: ");
    lcd.print(Tkw);                                                 // Zet de variable Tkw neer
    lcd.setCursor(0,3);                                             // Ik ben er niet helemaal zeker van dat we die cursor echt al terug moeten zetten
    lcd.print("OPENING: ");  
    lcd.setCursor(10,3);                                            // Zet de cursor op de vierde regel op de 12 positie.
    lcd.print("T-az: ");                                            // Zet de tekst neer: "T-az:"
   // lcd.print( EtOH,2);
   // mm = 16;                                                      // Het menu is gemaakt, nu gaan we naar de volgende stap, namelijk bediening ervan
  }                                                                 // Sluit MM 4; het menu is gemaakt
// if (mm ==16) 
 // {
 // if (KeyDet){                                                    // Het volgende word uitgevoerd omdat we een nieuwe toets hebben gezien, anders overgeslagen
 // KeyDet = 0;                                                     // We gaan nu een nieuwe toetsdruk verwerken, dus deze nieuwe toetsdruk kan nu als eerste gewist worden zodat we niets dubbel doen 
 // if (key ==OK) {                                                 // Waneer toets (4) OK werd geduwd
 // Item = 1;                                                       // Zet Item terug, anders zouden we per ongeluk het menu de voelgnde keer op de verkeerde plaats binnenkomen en er gelijk weer uit raken voor we er goed en wel in zijn.
//  mm = 15;                                                        // Zet menu mode terug zodat we het volgende "rondje" het menu hebben verlaten
//  key = -1;                                                       // Wis key waarde ( -1 is geen key geregistreerd) zodat ie niet de volgende ronde nog blijft hangen.
   //     }                                                         // Sluit Instellingen OK
  //if (key ==Esc)                                                  // Waneer toets 3 "Esc" gedetecteerd werd ga dan naar menu 2
 // {                                                               // 3    
 // mm = 2;                                                         // zie hierboven: ga naar menu modus 2
   // }                                                             // -- Sluit KeyDet --
                                                                    // -- Sluit mm 5 --
  }
     
  //////////////////////////////////////////////////////////////// ZET SPANNING OM IN TOETS NUMMER /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 int get_key(unsigned int input)
{                                                                   // 1
  int k;
  for (k = 0; k < NUM_KEYS; k++)                                    // We gaan tellen
{                                                                   // 2
  if (input < adc_key_val[k])                                       // Zou meer betrouwbaar moeten zijn omdat het naar bereiken kijkt in plaats van naar vaste waardes.
{                                                                   // 3
  return k;                                                         // Zorgt er voor dat de for loop beëdigd word
}                                                                   // sluit 3                                                            
}                                                                   // sluit 2
  if (k >= NUM_KEYS)k = -1;                                         // Er is geen geldige toets gedrukt
  return k;                                                         // Dus beëindig de loop en wacht een volgdende toetsdruk af
}                                                                   // sluit 1

////////////////////////////////////////////////////////////////// Weergave van de temperatuur sensoren ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////




//////////////////////////////////////////////////////////////// EINDE PROGRAMMA //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  

Nu het volgende hierbij heb ik jullie hulp nodig.
op de foto zie je het menu zoals die er staat tijdens het distilleren op handbediening.
ik wil nu met de pijl omhoog en pijl omlaag de stappenmotor bedienen.
ik begin dus met 0 = naaldkraan dicht en met pijltje omhoog 2 dan 3 enz tot 20 en met het pijltje omlaag weer terug bv 20 dan 19 enz.
Ik zou die 20 stappen zelf willen invullen met steps.
bv 1 is 10 steps open 2 is 30 steps open 3 is 35 open enz.
Waarom niet in gelijke stappen zul je zeggen ?
omdat bij het stoken vaak met druppels word afgenomen dus ik wil eerst kleine stappen nemen en hoe hoger dan iets grotere stappen.
Haha moeilijk uit te leggen. hoop dat jullie het begrijpen.
dus met de function map zal dit niet lukken denk ik .
ook zou ik dan achter opening aan willen geven welke opening dan is geselecteerd.

ik kan natuurlijk elke keer een menu opbouwen.
maar dan moet ik er 20 maken.
volgens mij moet dit makkelijker kunnen.

De knoppen werken al zoals het moet in het programma
zoals je kunt zien in de code.

Ik ga nu aan het lezen en proberen.
Wacht met ongeduld op een idee van jullie haha.

Ik ben een stuk veder met de stappen neer zetten in het menu.
Ik heb echter 1 probleem.
waneer met de pijl naar onder terug tel vanaf bv 11
dan gaat hij netjes naar 10 maar als ik dan naar 9 ga zet hij dat netjes neer.
alleen bijft dan de nul van 10 staan

van 0 tot 20 gaat goed en van 20 naar 10 ook alleen wist hij dus niet de nul van 10
en komt er in beeld te staan 90 80 70 60
dus het klopt wel maar die nul moet hij wissen als ik van 10 naar 9 ga.
hier het stukje code wat ik er voor gebruik

    lcd.clear();                                                     // Wis het display zodat we klaar zijn voor het normale scherm
    lcd.setCursor(0,0);                                              // eerste regel, eerste positie
    lcd.print("Temp.Uit:");
    lcd.print(Temp);                                                 // Zet de variable Temp neer
    lcd.setCursor(0,1);                                              // tweede regel, eerste positie
    lcd.print("Temp.in: ");
    lcd.print(Tin);                                                  // Zet de variable Tin neer
    lcd.setCursor(0,2);                                              // Derde regel, eerste positie
    lcd.print("Temp.Kw: ");
    lcd.print(Tkw);                                                  // Zet de variable Tkw neer
    lcd.setCursor(0,3);                                         
    lcd.print("OPENING: ");  
   // lcd.setCursor(10,3);                                           // Zet de cursor op de vierde regel op de 11 positie.
   // lcd.print("T-az: ");                                           // Zet de tekst neer: "T-az:"
   // lcd.print( EtOH,2);

   mm = 16;                                                          // We hebben het scherm gewist en het menu word al weergegeven, nu kunnen we naar de volgende menu modus schakelen waar de pijltjes worden afgehandeld
  }                                                                  // het scherm voor menu mode 15 is gemaakt, en we hebben al doorgeschakeld naar mode 16

  if (mm ==16){ 
    //lcd.clear();
    lcd.setCursor(8,3);                                            
    lcd.print(Stap);
      
  if (KeyDet){                                                        // Het volgende word uitgevoerd omdat we een nieuwe toets hebben gezien, anders overgeslagen
                                                                      // Omdat we de toets vrij moeten geven voordat we naar het volgende item gaan, moeten we kijken of de waarde nieuw is of niet
  KeyDet = 0;                                                         // KeyDet word verderop weer gebruikt, en moet nu gereset worden zodat er niet per ongeluk een niet gedrukte toets word herhaald.
  if ((key)==Omhoog) Stap++;                                          // Toets Omhoog, dus Stap verhogen
  if ((key)==Omlaag) Stap--;                                          // Toets Omlaag, dus Stap verlagen
  if ((Stap)==21) Stap=20;                                            // waneer 21 is bereikt blijf 20 weergeven
  if ((Stap)==-1) Stap=0;                                             // waneer -1 is bereikt blijf 0 weergeven

Hoi homedistiller.

Ik ga zo even klagen bij het forum onderhoudsteam, want van dit onderwerp word ik niet op de hoogte gebracht als er iets nieuws is.

Om jouw laatste probleem op te lossen, kun je kijken of de variabele "stap" 9 is.
Wanneer dat het geval is, kun je op positie 9,3 een spatie (" ") zetten.
De nul verdwijnt dan als sneeuw voor de zon.
Wanneer de oude waarde 8 was, verdwijnt de inhoud van 9,3 ook, maar die was op dat moment al leeg.
Dus je hoeft niet per se te kijken of je van 10 naar 9 bent gegaan, en bij getallen lager dan 9 hoef je deze actie niet uit te voeren.

Het kan af en toe zo makkelijk zijn.
inderdaad even een spatie neerzetten en het is opgelost.

  if (mm ==16){ 
    //lcd.clear();
    lcd.setCursor(9,3);
    lcd.print(" ");
    lcd.setCursor(8,3);                                            
    lcd.print(Stap);

nu het volgende en ik ben een heel eind om de handbediening te gaan uitproberen .

ik wil dus met de stappen 0 tm 20 de stappenmotor gaan aansturen.
Nu vroeg ik mij af als hij gehomed is zet hij hem op 0

  stepper1.setCurrentPosition(0);                                     // Set the current position as zero for now

als ik nu bv met een stukje code zeg :

  if ((Stap)==1){
    
    stepper1.setMaxSpeed(300.0);                                        // Set Max Speed of Stepper (Slower to get better accuracy)
    stepper1.setAcceleration(300.0);                                    // Set Acceleration of Stepper
    stepper1.moveTo(-5000);  
    stepper1.run();
  }

Dan gaat hij CCW 5000 stappen zetten en stopt hij.
Stel dat ik dan weer zeg met een if bij Stap2 move to -5200
dan gaat hij toch weer 200 stappen veder dus als ik dit herhaal voor de 20 stappen dan werkt het toch ook als ik snel twee stappen terug ga ?
Of denk ik nu verkeerd ?
Of moet ik het op een hele andere manier het aanpakken ?