Go Down

Topic: EEPROM Schrijven / Lezen (Read 225 times) previous topic - next topic

achimpieters

Hallo allemaal!

Stap je voor Stapje kom ik vooruit en mij Code wordt langer en langer...  :D
Ik ben nu aangekomen bij mijn idee om een "vaste value" in het EEPROM geheugen te schrijven, zodat dit vast gegeven als uitgangspunt genomen kan worden.

Het probleem alles "werkt" de stepcount wordt weggeschreven naar de eeprom, vervolgens (laatste gedeelt van de code) als ik op Up druk laat de Serial monitor continu 252.00 zien (loop) reset ik de Arduino en druk ik op Down krijg ik herhaaldelijk ovf te zien  :o

iemand een idee?

Code: [Select]




// ************* Include Library's *************
#include <EEPROM.h>





// ************* Define Pins on Arduino / ESP8266 *************
const int stepPin = 3;        // Arduino Pin 3 / ESP8266 GPIO 14
const int dirPin = 4;         // Arduino Pin 4 / ESP8266 GPIO 16
const int EnablePin = 8;      // Arduino Pin 8 / ESP8266 GPIO 13
const int SleepPin = 9;       // Arduino Pin 9 / ESP8266 GPIO 12
//const int Motor0Pin = ;     // Arduino Not Connected / ESP8266 Not Connected
//const int Motor1Pin = 10;   // Arduino Pin 3 / ESP8266 GPIO 10
//const int Motor2Pin = 11;   // Arduino Pin 3 / ESP8266 GPIO 9

const int UpPin = 5;          // Arduino Pin 5 / ESP8266 GPIO 5
const int StopPin = 6;        // Arduino Pin 6 / ESP8266 GPIO 4
const int DownPin = 7;        // Arduino Pin 7 / ESP8266 GPIO 2

// ************* Define variables *************
int UpState = 0;              // variable for reading the pushbutton status
int StopState = 0;            // variable for reading the pushbutton status
int DownState = 0;            // variable for reading the pushbutton status

int stepCount = 0;            // number of steps the motor has taken


// ************* Define variables for Programming *************
long buttonTimer = 0;
long longPressTime = 3000;

boolean ButtonPress = false;
boolean LongButtonPress = false;

int ProgramState = 0;         // The current State of the Program
int address = 0;              // The current address in the EEPROM
float f = 0.00f;              //Variable to store data read from EEPROM.




void setup() {
  // initialize the serial port:
  Serial.begin(9600);

  // Sets the two pins as Outputs
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);


  pinMode(UpPin, INPUT_PULLUP);
  pinMode(StopPin, INPUT_PULLUP);
  pinMode(DownPin, INPUT_PULLUP);

  pinMode(EnablePin, OUTPUT);
  pinMode(SleepPin, OUTPUT);


}


void loop() {
  // read the state of the pushbutton value:
  UpState = digitalRead(UpPin);
  StopState = digitalRead(StopPin);
  DownState = digitalRead(DownPin);

  // ************* START PROGRAMMING SECTION *************
  if (StopState == HIGH) {
    if (ButtonPress == false) {
      ButtonPress = true;
      buttonTimer = millis();
    }
    if ((millis() - buttonTimer > longPressTime) && (LongButtonPress == false)) {
      LongButtonPress = true;
      Serial.println ("Start programming");
      ProgramState = 1;
    }
  } else {
    if (ButtonPress == true) {
      if (LongButtonPress == true) {
        LongButtonPress = false;
      } else {



       
        EEPROM.update(address, (stepCount / 200 ));  //Write a byte to the EEPROM. EEPROM.write(address, value)
        address = address + 1;
        if (address == EEPROM.length()) {
          address = 0;
          Serial.println("Writing to EEPROM ...");
          delay(100);
        }



       
        Serial.println ("Done programming");
        ProgramState = 0;
      }
      ButtonPress = false;
    }
  }
  // ************* Start Step Counting *************
  if (UpState == HIGH && ProgramState == 1) {
    // turn Up:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction

    // Makes 200 pulses for making two full cycle rotation
    for (int x = 0; x < 50; x++) {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }
    Serial.print("steps:");
    Serial.println(stepCount);
    stepCount++;
  }
  if (DownState == HIGH  && ProgramState == 1) {
    // turn Down:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, LOW); //Changes the rotations direction

    // Makes 200 pulses for making two full cycle rotation
    for (int x = 0; x < 50; x++) {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }
    Serial.print("steps:");
    Serial.println(stepCount);
    stepCount--;
  }
  // ************* End Step Counting *************


  // ************* END PROGRAMMING SECTION *************






 // ************* START BASIC SECTION *************

 
  // check if the upbutton is pressed. if it is, the upState is HIGH:
  if (UpState == HIGH && ProgramState == 0) {
    // turn Up:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction

    // get Steps from EEPROM And Trun
    for (int x = 0; x < EEPROM.get(address, f); x++)
     Serial.println(f, 3);    //This may print 'ovf, nan' if the data inside the EEPROM is not a valid float.
    {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }
    Serial.println("Blinds UP");
  }

  // check if the downbutton is pressed. if it is, the downState is HIGH:
  if (StopState == HIGH  && ProgramState == 0) {
    // turn Down:
    digitalWrite(SleepPin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(EnablePin, LOW); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    delay(1000); // One second delay
  }

  // get Steps from EEPROM And Trun
  if (DownState == HIGH  && ProgramState == 0) {
    // turn Down:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, LOW); //Changes the rotations direction

    // Makes 200 pulses for making two full cycle rotation
    for (int x = 0; x < EEPROM.get(address, f); x--)
     Serial.println(f, 3);    //This may print 'ovf, nan' if the data inside the EEPROM is not a valid float.
    {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }

    Serial.println("Blinds Down");

  }

  else {

  }

}



sterretje

#1
May 19, 2017, 07:51 am Last Edit: May 19, 2017, 07:52 am by sterretje
EEPROM.update schrijft een (1) enkele byte naar de EEPROM. Ik vermoed dat je EEPROM.get gebruikt om het terug te lezen maar omdat daar een float gebruikt worden er vier bytes terug gegeven.. Je hebt echter slechts 1 byte geschreven.

Ik heb geen idee wat je code precies is verondersteld te doen maar je kunt proberen the EEPROM.update te vervangen door EEPROM.put
Code: [Select]
EEPROM.put(address, (float)(stepCount / 200 ));

Niet getest; de cast naar een float forceert dat stepCound/200 als een float wordt weggeschreven.
If you understand an example, use it.
If you don't understand an example, don't use it.

Electronics engineer by trade, software engineer by profession. Trying to get back into electronics after 15 years absence.

achimpieters

@Sterretje

Dank je wel voor je feedback, klinkt logisch!  :smiley-lol:

Ik ga hiermee eens aan de slag!

achimpieters

NOPE  :smiley-sad: werkt niet...

Korst samengevat:

De bedoeling is dat de step die worden geteld worden weggeschreven naar de EEPROM.
vervolgens moet ik dit getal weer terug halen, zodat ik de motor weer dit aantal stappen kan laten maken.

Dus kort door de bocht EEPROM.update, omdat indien er reeds een getal aanwezig is dit overschreven moet worden met de nieuwe waarde.

en EEPROM.get, haal me het getal op zodat de motor het benodigde aantal stappen kan maken.

nog iemand een idee?

sterretje

Dan heb je iets verkeerd gedaan ;)

Code: [Select]
#include <EEPROM.h>

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

  float pi = 3.14;
  float e = 2.71;
  float data;

  EEPROM.put(0, pi);
  EEPROM.get(0, data);
  Serial.println(data);

  EEPROM.put(0, e);
  EEPROM.get(0, data);
  Serial.println(data);


}

void loop()
{
}

Dit print 3.14 en 2.71.

Gewoon simpel beginnen :D
If you understand an example, use it.
If you don't understand an example, don't use it.

Electronics engineer by trade, software engineer by profession. Trying to get back into electronics after 15 years absence.

achimpieters

@ Sterretje

Bedankt voor je feedback, ga hier morgen mee aan de slag!  :smiley-lol:  :smiley-lol:

achimpieters

@sterretje

Je code werkt like a charm! :D

maar ik krijg hem niet geïntrigeerd in mij code?
ik weet dan ook niet hoe ik mij stepCount

Code: [Select]
int stepCount = 0;            // number of steps the motor has taken

naar een float kan krijgen?

vervolgens moet  de weggeschreven data weer opgehaald worden in

Code: [Select]
for (int x = 0; x < STEPS; x++)

om het aantal steps aan te geven dat genomen moeten worden.


nog een pointer?  :smiley-confuse:

de gehele code nogmaals als referentie:

Code: [Select]

/* Project name:  Curtains & Blinds
   Project URI:
   Description:  Curtains & Blinds - Basic Software
   Version: 4.0.0
   License: MIT
*/


// ************* Include Library's *************
#include <EEPROM.h>





// ************* Define Pins on Arduino / ESP8266 *************
const int stepPin = 3;        // Arduino Pin 3 / ESP8266 GPIO 14
const int dirPin = 4;         // Arduino Pin 4 / ESP8266 GPIO 16
const int EnablePin = 8;      // Arduino Pin 8 / ESP8266 GPIO 13
const int SleepPin = 9;       // Arduino Pin 9 / ESP8266 GPIO 12
//const int Motor0Pin = ;     // Arduino Not Connected / ESP8266 Not Connected
//const int Motor1Pin = 10;   // Arduino Pin 3 / ESP8266 GPIO 10
//const int Motor2Pin = 11;   // Arduino Pin 3 / ESP8266 GPIO 9

const int UpPin = 5;          // Arduino Pin 5 / ESP8266 GPIO 5
const int StopPin = 6;        // Arduino Pin 6 / ESP8266 GPIO 4
const int DownPin = 7;        // Arduino Pin 7 / ESP8266 GPIO 2

// ************* Define variables *************
int UpState = 0;              // variable for reading the pushbutton status
int StopState = 0;            // variable for reading the pushbutton status
int DownState = 0;            // variable for reading the pushbutton status

int stepCount = 0;            // number of steps the motor has taken


// ************* Define variables for Programming *************
long buttonTimer = 0;
long longPressTime = 3000;

boolean ButtonPress = false;
boolean LongButtonPress = false;

int ProgramState = 0;         // The current State of the Program




void setup() {
  // initialize the serial port:
  Serial.begin(9600);

  // Sets the two pins as Outputs
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);


  pinMode(UpPin, INPUT_PULLUP);
  pinMode(StopPin, INPUT_PULLUP);
  pinMode(DownPin, INPUT_PULLUP);

  pinMode(EnablePin, OUTPUT);
  pinMode(SleepPin, OUTPUT);


}


void loop() {
  // read the state of the pushbutton value:
  UpState = digitalRead(UpPin);
  StopState = digitalRead(StopPin);
  DownState = digitalRead(DownPin);

  // ************* START PROGRAMMING SECTION *************
  if (StopState == HIGH) {
    if (ButtonPress == false) {
      ButtonPress = true;
      buttonTimer = millis();
    }
    if ((millis() - buttonTimer > longPressTime) && (LongButtonPress == false)) {
      LongButtonPress = true;
      Serial.println ("Start programming");
      ProgramState = 1;
    }
  } else {
    if (ButtonPress == true) {
      if (LongButtonPress == true) {
        LongButtonPress = false;
      } else {



 
          Serial.println("Writing to EEPROM ...");
          delay(100);
        }



       
        Serial.println ("Done programming");
        ProgramState = 0;
      }
      ButtonPress = false;
    } 
  // ************* Start Step Counting *************
  if (UpState == HIGH && ProgramState == 1) {
    // turn Up:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction

    // Makes 200 pulses for making two full cycle rotation
    for (int x = 0; x < 50; x++) {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }
    Serial.print("steps:");
    Serial.println(stepCount);
    stepCount++;
  }
  if (DownState == HIGH  && ProgramState == 1) {
    // turn Down:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, LOW); //Changes the rotations direction

    // Makes 200 pulses for making two full cycle rotation
    for (int x = 0; x < 50; x++) {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }
    Serial.print("steps:");
    Serial.println(stepCount);
    stepCount--;
  }
  // ************* End Step Counting *************


  // ************* END PROGRAMMING SECTION *************






 // ************* START BASIC SECTION *************

 
  // check if the upbutton is pressed. if it is, the upState is HIGH:
  if (UpState == HIGH && ProgramState == 0) {
    // turn Up:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction

    // get Steps from EEPROM And Trun
    for (int x = 0; x < 200; x++)
    {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }
    Serial.println("Blinds UP");
  }

  // check if the downbutton is pressed. if it is, the downState is HIGH:
  if (StopState == HIGH  && ProgramState == 0) {
    // turn Down:
    digitalWrite(SleepPin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(EnablePin, LOW); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    delay(1000); // One second delay
  }

  // get Steps from EEPROM And Trun
  if (DownState == HIGH  && ProgramState == 0) {
    // turn Down:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, LOW); //Changes the rotations direction

    // Makes 200 pulses for making two full cycle rotation
    for (int x = 0; x < 200; x++)
     
    {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }

    Serial.println("Blinds Down");

  }

  else {

  }

}










MAS3

#7
May 20, 2017, 10:41 pm Last Edit: May 20, 2017, 10:42 pm by MAS3
Hoi achimpieters.

Wij zijn allemaal wel geïntrigeerd door jouw code hoor, daarom reageren we er ook op ;).

Om een float te maken, moet je 'm geen int noemen, maar float.

Dus zo:
Code: [Select]
float stepCount = 0;            // number of steps the motor has taken

Soms zijn dingen zo simpel op te lossen.

De variabele STEPS die in je 2e code blokje staat, word in je 3e code blok niet genoemd.
Dus dat voorbeeld wat je schijnbaar ergens gezien hebt, moet je dan wel aanpassen zodat de variabele past bij eentje die je zelf al in je bestaande code hebt.
EN anders moet je 'm aanmaken.
Have a look at "blink without delay".
Did you connect the grounds ?
Je kunt hier ook in het Nederlands terecht: http://arduino.cc/forum/index.php/board,77.0.html

sterretje

Je laatste code bevat geen lezen of schrijven van de eeprom; dat zal ons niet helpen om jou te helpen. Je moet een versie geven die niet werkt en aangeven wat er niet werkt.

Hieronder een stukje code om je steps weg te schrijven; ik heb eigenlijk geen idee waarom je een float gebruikt.
Code: [Select]

  int stepsAsInt = 100 / 9;
  int dataAsInt;

  EEPROM.put(0, stepsAsInt);
  EEPROM.get(0, dataAsInt);
  Serial.println(dataAsInt);


  float stepsAsFloat = 100/9.0;  // <----
  float dataAsFloat;

  EEPROM.put(0, stepsAsFloat);
  EEPROM.get(0, dataAsFloat);
  Serial.println(dataAsFloat);

Geef even speciale aandacht hoe stepsAsFloat is ingevuld. Als je daar 9 inplaats van 9.0 gebruikt wordt er een integer deling gedaan en is het resultaat 11 (en kun je net zo goed stepsAsInt gebruiken); met 9.0 wordt er een floating point deling gedaan en is het resultaat 11.11....

Verder hoog je in je originele post het eeprom adres op met 1; ten eerste heb ik geen idee waarom en ten tweede zal dat alleen werken voor 8-bit variabelen (byte, char) maar niet voor floats,  integers en andere types. Voor die laatsten moet je het adres ophogen met de sizeof() van de variable of van het type.
Code: [Select]
// increment address with size of a float
address+=sizeof(float);
// increment address with size of integer variable
address+=sizeof(stepsAsInt);
If you understand an example, use it.
If you don't understand an example, don't use it.

Electronics engineer by trade, software engineer by profession. Trying to get back into electronics after 15 years absence.

achimpieters

@ sterretje

krijg het niet aan het werken? hoogstwaarschijnlijk is mijn snapper kapot   ::)

zoals je kunt zien in de gehele code doe ik eerste de stappen wegschrijven, maar hierna gaat hij verder met tellen.

Code: [Select]
(int x = 0; x < EEPROM.get(0, stepCount); x++)

terwijl er eigenlijk de stappen opgehaald moeten worden om vervolgens te +en tot dat de stappen gelijk zijn.

vervang ik EEPROM.get(0, stepCount) voor 200 stappen maakt de motor mooi 200 stappen?

abracadabra simsalabim..... :o

Code: [Select]

/* Project name:  Curtains & Blinds
   Project URI:
   Description:  Curtains & Blinds - Basic Software
   Version: 23-05-2017 - 9:03
   License: MIT
*/


// ************* Include Library's *************
#include <EEPROM.h>





// ************* Define Pins on Arduino / ESP8266 *************
const int stepPin = 3;        // Arduino Pin 3 / ESP8266 GPIO 14
const int dirPin = 4;         // Arduino Pin 4 / ESP8266 GPIO 16
const int EnablePin = 8;      // Arduino Pin 8 / ESP8266 GPIO 13
const int SleepPin = 9;       // Arduino Pin 9 / ESP8266 GPIO 12
//const int Motor0Pin = ;     // Arduino Not Connected / ESP8266 Not Connected
//const int Motor1Pin = 10;   // Arduino Pin 3 / ESP8266 GPIO 10
//const int Motor2Pin = 11;   // Arduino Pin 3 / ESP8266 GPIO 9

const int UpPin = 5;          // Arduino Pin 5 / ESP8266 GPIO 5
const int StopPin = 6;        // Arduino Pin 6 / ESP8266 GPIO 4
const int DownPin = 7;        // Arduino Pin 7 / ESP8266 GPIO 2

// ************* Define variables *************
int UpState = 0;              // variable for reading the pushbutton status
int StopState = 0;            // variable for reading the pushbutton status
int DownState = 0;            // variable for reading the pushbutton status

int stepCount = 0;            // number of steps the motor has taken


// ************* Define variables for Programming *************
long buttonTimer = 0;
long longPressTime = 3000;

boolean ButtonPress = false;
boolean LongButtonPress = false;

int ProgramState = 0;         // The current State of the Program


void setup() {
  // initialize the serial port:
  Serial.begin(9600);

  // Sets the two pins as Outputs
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);


  pinMode(UpPin, INPUT_PULLUP);
  pinMode(StopPin, INPUT_PULLUP);
  pinMode(DownPin, INPUT_PULLUP);

  pinMode(EnablePin, OUTPUT);
  pinMode(SleepPin, OUTPUT);


}


void loop() {
  // read the state of the pushbutton value:
  UpState = digitalRead(UpPin);
  StopState = digitalRead(StopPin);
  DownState = digitalRead(DownPin);

  // ************* START PROGRAMMING SECTION *************
  if (StopState == HIGH) {
    if (ButtonPress == false) {
      ButtonPress = true;
      buttonTimer = millis();
    }
    if ((millis() - buttonTimer > longPressTime) && (LongButtonPress == false)) {
      LongButtonPress = true;
      Serial.println ("Start programming");
      ProgramState = 1;
    }
  } else {
    if (ButtonPress == true) {
      if (LongButtonPress == true) {
        LongButtonPress = false;
      } else {



       
          EEPROM.put(0, stepCount);
          Serial.println("Writing to EEPROM ...");
          delay(100);
       



       
        Serial.println ("Done programming");
        ProgramState = 0;
      }
      ButtonPress = false;
    }
  }
  // ************* Start Step Counting *************
  if (UpState == HIGH && ProgramState == 1) {
    // turn Up:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction

    // Makes 200 pulses for making two full cycle rotation
    for (int x = 0; x < 50; x++) {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }
    Serial.print("steps:");
    Serial.println(stepCount);
    stepCount++;
  }
  if (DownState == HIGH  && ProgramState == 1) {
    // turn Down:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, LOW); //Changes the rotations direction

    // Makes 200 pulses for making two full cycle rotation
    for (int x = 0; x < 50; x++) {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }
    Serial.print("steps:");
    Serial.println(stepCount);
    stepCount--;
  }
  // ************* End Step Counting *************


  // ************* END PROGRAMMING SECTION *************






 // ************* START BASIC SECTION *************

 
  // check if the upbutton is pressed. if it is, the upState is HIGH:
  if (UpState == HIGH && ProgramState == 0) {
    // turn Up:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, HIGH); // Enables the motor to move in a particular direction

    // get Steps from EEPROM And Trun
    for (int x = 0; x < EEPROM.get(0, stepCount); x++)
    {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }
    Serial.println("Blinds UP");
      Serial.println(stepCount);
  }

  // check if the downbutton is pressed. if it is, the downState is HIGH:
  if (StopState == HIGH  && ProgramState == 0) {
    // turn Down:
    digitalWrite(SleepPin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(EnablePin, LOW); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    delay(1000); // One second delay
  }

  // get Steps from EEPROM And Trun
  if (DownState == HIGH  && ProgramState == 0) {
    // turn Down:
    digitalWrite(SleepPin, HIGH); //Enable/disable low-power sleep mode, LOW - Sleep, HIGH - Active
    digitalWrite(EnablePin, LOW); //Enable/disable the stepper driver, HIGH - Disable, LOW - Enable
    digitalWrite(dirPin, LOW); //Changes the rotations direction

    // Makes 200 pulses for making two full cycle rotation
    for (int x = 0; x < EEPROM.get(0, stepCount); x++) 
    {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(500);
    }
    Serial.println(stepCount);
    Serial.println("Blinds Down");

  }

  else {

  }

}








nicoverduin

Volgens mij klopt je redenering over de knoppen niet:
a) Je gebruikt INPUT_PULLUP dus de ingangen zijn bij niet ingedrukt standaard dus HIGH.
b) Jij test of ze hoog zijn dus dat zijn ze altijd tenzij ze ingedrukt worden. En dan worden ze LOW.
Met vriendelijke groet / kindest regards
Nico Verduin
www.verelec.nl
Do not PM me for personal consultancy unless you are willing to pay for it.

Go Up