Blink without delay voor stappenmotor

Arduino specifieke Software
Berichten: 7
Geregistreerd: 29 Sep 2018, 11:35

Blink without delay voor stappenmotor

Berichtdoor Bertje46 » 02 Okt 2018, 23:16

Hallo,

Ik zit al een week of wat te zwoegen om een code te maken voor mijn zelfgemaakte broedmachine.
Ik heb eerst 2 aparte code's gemaakt, 1 voor een stappenmotor met een easy driver en de tweede om de temperatuur te meten in de kast met een ds18b20 sensor.

Als ik deze apart test dan werkt alles zoals de bedoeling is maar gecombineerd, dan werkt ook alles, kom ik in de knoei met de Delay opdracht.

Zodra de stappenmotor zijn draai heeft gemaakt dan gaat delay een uurtje wachten totdat de volgende regel uitgevoerd wordt. Hierdoor wordt de temperatuur pas om het uur ververst ipv om de 2 seconden! (De stappenmotor draait een rekje waar de eieren op liggen)

Hier op het forum wordt steeds verwezen naar de code "Blink without Delay" voor dit soort problemen. Ook hier ben ik mee aan het stoeien geweest maar kom er niet uit!

Dus is mijn vraag is of er iemand mij op weg kan helpen om dit in mijn code te verwerken ipv delay zodat de ds18b20 constant uitgelezen wordt en de stappenmotor om het uur 380 stappen draait?

Dit is mijn code;

Code: Alles selecteren
/********************************************************************/
// First we include the libraries
#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>

/*******************************************************************/
// int stepper pins
int smDirectionPin = 2; //Direction pin
int smStepPin = 3; //Stepper pin
int smEnablePin = 7; //Motor enable pin
//int interval = 5000; //interval is ?? seconden

const unsigned long SECOND = 1000;
const unsigned long HOUR = 3600*SECOND;
const unsigned int numOfDays = 51;
int i;
int j;

/********************************************************************/
// set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27,16,2);
/********************************************************************/
// Data wire is plugged into pin 2 on the Arduino
#define ONE_WIRE_BUS 4
/********************************************************************/
// Setup a oneWire instance to communicate with any OneWire devices 
// (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
/********************************************************************/
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
/********************************************************************/



void setup(void)
{
 // start serial port
 Serial.begin(9600);
 
 Serial.println("Broedmachine Temperature IC Control");
 // Start up the library
 sensors.begin();
 lcd.begin();
/**********************************************************************/
// Stepper pinmode
 /*Sets all pin to output; the microcontroller will send them(the pins) bits, it will not expect to receive any bits from thiese pins.*/
  pinMode(smDirectionPin, OUTPUT);
  pinMode(smStepPin, OUTPUT);
  pinMode(smEnablePin, OUTPUT);
 
  digitalWrite(smEnablePin, HIGH); //Disbales the motor, so it can rest untill it is called uppond
/********************************************************************/
}




void loop(void)
{
 // call sensors.requestTemperatures() to issue a global temperature
 // request to all devices on the bus
/********************************************************************/
// Seriélle monitor
 Serial.print(" Temperatuur..Serial ");
 sensors.requestTemperatures(); // Send the command to get temperature readings
 Serial.println("  DONE");
 Serial.print("Temperature is: ");
 Serial.print(sensors.getTempCByIndex(0)); // Why "byIndex"?
 // You can have more than one DS18B20 on the same bus. 
   // 0 refers to the first IC on the wire
/********************************************************************/
 //  Gegevens op LCD
 lcd.setCursor (0, 0);
 lcd.print("Temperatuur LCD.");
 lcd.setCursor(0, 1);
 lcd.print(sensors.getTempCByIndex(0)); 
   
   delay(1000);

  /********************************************************************/
  /*Here we are calling the rotate function to turn the stepper motor*/
  rotate(380, 0.5); //The motor rotates 380 steps clockwise with a speed of 0.5 (medium)
  delay(HOUR);
  rotate(-380, 1); //The motor rotates 380 steps counter clockwise with a speed of 1 (fast)
  delay(HOUR);
}
 
/*The rotate function turns the stepper motor. Tt accepts two arguments: 'steps' and 'speed'*/
void rotate(int steps, float speed){
  digitalWrite(smEnablePin, LOW); //Enabling the motor, so it will move when asked to
 
  /*This section looks at the 'steps' argument and stores 'HIGH' in the 'direction' variable if */
  /*'steps' contains a positive number and 'LOW' if it contains a negative.*/
  int direction;
 
  if (steps > 0){
    direction = HIGH;
  }else{
    direction = LOW;
  }
 
  speed = 1/speed * 500; //Calculating speed
  steps = abs(steps); //Stores the absolute value of the content in 'steps' back into the 'steps' variable
 
  digitalWrite(smDirectionPin, direction); //Writes the direction (from our if statement above), to the EasyDriver DIR pin
 
  /*Steppin'*/
  for (int i = 0; i < steps; i++){
    digitalWrite(smStepPin, HIGH);
    delayMicroseconds(speed);
    digitalWrite(smStepPin, LOW);
    delayMicroseconds(speed);
  }
 
  digitalWrite(smEnablePin, HIGH); //Disbales the motor, so it can rest untill the next time it is called uppond
}

Advertisement

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

Re: Blink without delay voor stappenmotor

Berichtdoor Koepel » 02 Okt 2018, 23:35

Dit is mijn eigen voorbeeld: https://gist.github.com/Koepel/8dd3e8ad5d8628be21270fab1f5e9c1c.

Kun je dat eens proberen en kijken wat er op de seriële monitor te zien is. Kun je in de sketch zien dat er drie dingen gaande zijn, onafhankelijk van elkaar ?

Berichten: 7
Geregistreerd: 29 Sep 2018, 11:35

Re: Blink without delay voor stappenmotor

Berichtdoor Bertje46 » 03 Okt 2018, 20:06

Hoi Koepel,

Bedankt voor je reactie!

Wat ik te zien krijg is dit;


The sketch has started
.....Random...
Hello........
Hello........
HelloRandom........
HelloRandom........
Hello........
Hello.......Random.
Hello........
Hello..Random......
Hello......Random..
Hello........
Hello.Random.......
Hello........
Hello.Random.......
Hello........
Hello.......Random.
Hello........
Hello........
Hello.....Random...
Hello........
Hello........
Hello..Random......
Hello..

Ik ben al een beetje aan het spelen geweest met je code, ook diverse timer intervallen geprobeerd, dan zie je duidelijk het verschil.
Ben nu bezig om er even een simpele code (ds18b20) tussen te zetten om te zien wat en of het lukt!

Wordt vervolgd......

Berichten: 7
Geregistreerd: 29 Sep 2018, 11:35

Re: Blink without delay voor stappenmotor

Berichtdoor Bertje46 » 03 Okt 2018, 23:13

In principe werk het wel dat de motor apart werkt nu van de temperatuur meting maar de motor draait nu eerst links/rechts en wacht dan 10 sec dan weer links/rechts.
Dit is mijn code geworden, nog suggesties waar het probleem kan zitten?


Code: Alles selecteren
/*******************************************************************/
// int stepper pins
int smDirectionPin = 2; //Direction pin
int smStepPin = 3; //Stepper pin
int smEnablePin = 7; //Motor enable pin
//int interval = 5000; //interval is ?? seconden
/*******************************************************************/
/*******************************************************************/
//I2C bus support
#include <Wire.h>
//I2C
#include <LiquidCrystal_I2C.h>
//OneWire bus suport
#include <OneWire.h>
//DS18B20 temperature sensor support
#include <DallasTemperature.h>
//DS18B20 sensor pin
#define ONE_WIRE_BUS 4

// Setup a oneWire instance to communicate with any OneWire devices
// (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
 
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display
/**********************************************************************/
/**********************************************************************/
unsigned long previousMillisClockwise;
const unsigned long intervalClockwise = 10000;

unsigned long previousMillisCounterClockwise;
const unsigned long intervalCounterClockwise = 10000;


/*********************************************************************/
/*********************************************************************/

void setup()
{
  Serial.begin( 9600);
  lcd.begin();
  //lcd.backlight(); //Turns backlight on
  sensors.begin();
 
  Serial.println();
  Serial.println( "Broedmachine Temperature IC Control");
/**********************************************************************/
// Stepper pinmode
/*Sets all pin to output; the microcontroller will send them(the pins) bits, it will not expect to receive any bits from thiese pins.*/
  pinMode(smDirectionPin, OUTPUT);
  pinMode(smStepPin, OUTPUT);
  pinMode(smEnablePin, OUTPUT);
 
  digitalWrite(smEnablePin, HIGH); //Disbales the motor, so it can rest untill it is called uppond
/********************************************************************/
 
}

void loop()

  /************************************************************************************/
  unsigned long currentMillis = millis();
 
  if( currentMillis - previousMillisClockwise >= intervalClockwise)
  {
    rotate(380, 0.5); //The motor rotates 380 steps clockwise with a speed of 0.5 (medium)
    previousMillisClockwise = currentMillis;
   
   }
 
  if( currentMillis - previousMillisCounterClockwise >= intervalCounterClockwise)
  {
    rotate(-380, 0.5); //The motor rotates 380 steps clockwise with a speed of 0.5 (medium)
    previousMillisCounterClockwise = currentMillis; 
   
  }
 
 
  /*************************************************************************************/
 
  sensors.requestTemperatures();
 
  //Read first sensor
  float temp = sensors.getTempCByIndex(0);
 
  //Print first sensor results
  lcd.setCursor (0, 1 );
  lcd.print("T1: ");
  lcd.print(temp);
  lcd.print("      ");
}

/*The rotate function turns the stepper motor. Tt accepts two arguments: 'steps' and 'speed'*/
void rotate(int steps, float speed){
  digitalWrite(smEnablePin, LOW); //Enabling the motor, so it will move when asked to
 
  /*This section looks at the 'steps' argument and stores 'HIGH' in the 'direction' variable if */
  /*'steps' contains a positive number and 'LOW' if it contains a negative.*/
  int direction;
 
  if (steps > 0){
    direction = HIGH;
  }else{
    direction = LOW;
  }
 
  speed = 1/speed * 500; //Calculating speed
  steps = abs(steps); //Stores the absolute value of the content in 'steps' back into the 'steps' variable
 
  digitalWrite(smDirectionPin, direction); //Writes the direction (from our if statement above), to the EasyDriver DIR pin
 
  /*Steppin'*/
  for (int i = 0; i < steps; i++){
    digitalWrite(smStepPin, HIGH);
    delayMicroseconds(speed);
    digitalWrite(smStepPin, LOW);
    delayMicroseconds(speed);
  }
 
  digitalWrite(smEnablePin, HIGH); //Disbales the motor, so it can rest untill the next time it is called uppond
}

Berichten: 7
Geregistreerd: 29 Sep 2018, 11:35

Re: Blink without delay voor stappenmotor

Berichtdoor Bertje46 » 03 Okt 2018, 23:14

PS, waarom komt mijn code niet in een venster maar blijft het een grijs vlak?

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

Re: Blink without delay voor stappenmotor

Berichtdoor Koepel » 04 Okt 2018, 01:03

Wil je dat de stappenmotor +380 stappen doet, en een uur later -380 stappen?
Dat is dan een interval van een uur. Dat is dus één constructie met millis().

De temperatuur iedere twee seconden opvragen is een andere constructie met millis().
Als de temperatuur opvragen even onderbroken mag worden omdat de stappenmotor even draait, dan blijft de code eenvoudig.

Het lijkt alsof je in gedachten nog niet naar millis() bent omgeschakeld.
De functie millis() geeft de tijd, dat is alles, meer is het niet.
Wanneer je op een klok kijkt, dan zie je de tijd. Wanneer je millis() aanroept dan krijg je de tijd.
Het enige verschil is dat millis() geen uren en seconden geeft, maar het aantal milliseconden vanaf het moment dat de sketch begon.

Een sketch met millis() werkt het beste als de loop() heel vaak wordt uitgevoerd.
Stel dat de loop() duizenden keren per seconde wordt uitgevoerd.
Dan kijk je duizenden keren per seconde of er al twee seconden voorbij zijn. En je kijkt duizenden keren per seconde of er al een uur voorbij is. Als dat zo is, dan mag er eindelijk iets gedaan worden, bijvoorbeeld de temperatuur opvragen of de stappenmotor bewegen.

Je kijkt dus eigenlijk steeds op de klok: "zijn er al twee seconden voorbij?" en "is er al een uur voorbij?". En dat duizenden keren per seconde. Er gebeurt dus vrijwel nooit iets, het is vooral heel de tijd op de klok kijken.

Er zijn twee constructies met millis() nodig. Bijvoorbeeld met de globale variabelen zoals hieronder. De rest volgt dan eigenlijk vanzelf :?
Code: Alles selecteren
unsigned long previousMillisTemperature;
const unsigned long intervalTemperature = 2000; // 2 seconds interval for temperature

unsigned long previousMillisStepperMotor;
const unsigned long intervalStepperMotor = 1000UL * 3600UL; // 1 hour, "UL" means "unsigned long"


Wanneer je iets in de loop() zet zonder millis(), dan zou je dat als het ware duizenden keren per seconde willen doen. Dat is zelden nodig.
Dus de temperatuur opvragen en op het display zetten hoort nu in zo'n constructie met millis().

Iedere keer dat de loop() weer wordt uitgevoerd, dan verlies je de waarde van de lokale variabelen.
Om iets te onthouden voor de volgende keer heb je een globale variabele nodig. Je wilt bijvoorbeeld de richting voor de stappenmotor onthouden, zodat je de ene keer +380 kan doen en de volgende keer -380.

Kijk nu nog eens naar BlinkWithoutDelay: https://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
Zie je de globale variabele 'ledState' ? Die wordt gebruikt om de led te laten knipperen. Precies datzelfde het je nodig voor de stappenmotor. De led aan = stappenmotor +380. De led uit = stappenmotor -380.

Er zijn meerdere code tags op dit forum.
Er is [ code ] met [ / code ], met de knop "Code".
En ook [ code2 = cpp ] met [ / code2 ], met het drop-down menu "Select a Syntax" en dan "C++".

Berichten: 7
Geregistreerd: 29 Sep 2018, 11:35

Re: Blink without delay voor stappenmotor

Berichtdoor Bertje46 » 05 Okt 2018, 22:59

Bedankt voor je heldere uitleg Koepel!

Ik ben begonnen met de Blinkwithoutdelay en heb beetje bij beetje de code voor de stappenmotor er in gezet zoals je beschreef. Het resultaat is dat het ledje knippert en dat de motor 380 en -380 stappen doet :D met een delay van 10 seconden zonder dat het ledje stopt met knipperen (heb het uur even ingekort naar 10 sec).

De sketch van blinkwithoutdelay begreep ik wel maar om er ook een stappenmotor bij te maken viel niet mee!

Van de week weer verder om het ledje te vervangen voor de temperatuurmeter met lcd.

Als ik het klaar heb zal ik de code hier plaatsen zodat iemand anders er misschien ook nog wat aan heeft!

Berichten: 133
Geregistreerd: 10 Jan 2016, 16:39

Re: Blink without delay voor stappenmotor

Berichtdoor Nightmystic » 06 Okt 2018, 01:26

Bald engineer heeft een heleboel goede voorbeelden gemaakt waar je van kunt leren betreft het gebruik van millis.

Berichten: 7
Geregistreerd: 29 Sep 2018, 11:35

Re: Blink without delay voor stappenmotor

Berichtdoor Bertje46 » 26 Nov 2018, 23:20

Hallo,

Het is alweer even geleden, de code is inmiddels flink aangepast, maar ik loop nog steeds tegen 1 probleem aan.

Ik gebruik om te testen een uno, als stepperdriver een easydriver, als temperatuursensor een DS18B20 en een 16,2 lcd schermpje. Ook 3 ledjes die afhankelijk van de temperatuur gaan branden.
Voor het gemak heb ik een counter erbij gezet zodat ik kan zien over hoeveel tijd de steppermotor gaat draaien. Hier zit het probleem dat deze counter niet synchroon loopt met de stopwatch van mijn horloge en telefoon terwijl de motor wel exact elk uur draait, zelfs na 14 uur draait deze op de seconde af. Ik weet dat alles even een moment stil staat op het moment dat de motor draait maar op 5 minuten loopt de counter al 22 seconden achter ten opzichte van de stopwatch.

Ik hoop dat jullie mij kunnen helpen met het ontdekken waar het probleem zit?

Dit is de code;

Code: Alles selecteren
//**************************DS18B20 SENSOR + LCD***************************//
#include "LiquidCrystal_I2C.h"                        // I2C Lcd
LiquidCrystal_I2C lcd(0x27, 16, 2);

#include "OneWire.h"
#include "DallasTemperature.h"

#define ONE_WIRE_BUS_1 A0    //DS18B20 poort A0
OneWire ourWire1(ONE_WIRE_BUS_1);
DallasTemperature sensors(&ourWire1);


#define BlauweLed 4                                   //Ledpin 4 = Blauwe Led
#define GroeneLed 5                                   //Ledpin 5 = Groene Led
#define RodeLed 6                                     //Ledpin 6 = Rode Led

//EasyDriver Pins
int DirectionPin = 2;                                 //Direction pin 2
int StepPin = 3;                                      //Stepper pin 3
int EnablePin = 7;                                    //Motor enable pin 7
int DirectionState = LOW;                             // DirectionSate stepper

int stepCount = 0;                                    // Aantal stappen wat de motor heeft gedaan/number of steps the motor has taken
signed short minutes, secondes;                       // Tijdsaanduiding minuten en seconden
char timeline[16];                                    // Timer voor stappenmotor

unsigned long previousMillisTemp = 0;                 //temperatuur zonder delay
const unsigned long intervalTemp = 1000;

unsigned long previousMillisCount = 0;                //counter zonder delay - Telt af tot stepper een verder is
const unsigned long intervalCount = 1000;

unsigned long previousMillisStepperMotor = 0;         // steppermotor zonder delay
const unsigned long intervalStepperMotor = 1000UL * 3600UL; // 1 hour, "UL" means "unsigned long"  <--------- Tijd die de stepper wacht om verder te gaan.



//*************DS18B20****Calibratie temperatuursensor****************
float RawValue = 0;
float RawHigh = 100;                                  //Hoogste temperatuur kokend water
float RawLow = 0;                                     //Laagste temperatuur ijswater
float ReferenceHigh = 100;                            //Compensatie temperatuur volgens https://www.thermoworks.com/foodservice101_boiling_point
float ReferenceLow = 0;
float RawRange = RawHigh - RawLow;
float ReferenceRange = ReferenceHigh - ReferenceLow;


void setup(void) {
  {
    //Serial.begin(9600);
    lcd.begin();
    sensors.begin();
  }
  {
    pinMode(DirectionPin, OUTPUT);        //Maak de digitale pins als output
    pinMode(StepPin, OUTPUT);             //Maak de digitale pins als output
    pinMode(EnablePin, OUTPUT);           //Maak de digitale pins als output
    digitalWrite(EnablePin, HIGH);        //Maak de digitale pins als output
  }
  {
    pinMode(BlauweLed, OUTPUT);           //Maak de digitale pins als output
    pinMode(GroeneLed, OUTPUT);           //Maak de digitale pins als output
    pinMode(RodeLed, OUTPUT);             //Maak de digitale pins als output
  }
}

void loop(void) {
  unsigned long currentMillis = millis();       // deze is maar 1 x nodig

  //*************************STARTS STEPPER CODE***********************************/
  if ((unsigned long)(currentMillis - previousMillisStepperMotor) >= intervalStepperMotor) {
    previousMillisStepperMotor = currentMillis;

    rotate(380, 1);   //<--------- Verander hier eventueel het aantal stappen en snelheid
    //De Motor draait 380 stapen clockwise en counterclockwise met een snelheid van 0.5 van 1

    digitalWrite(EnablePin, HIGH);
    digitalWrite(DirectionPin, DirectionState);

    lcd.setCursor (12, 0);
    lcd.print(stepCount + 1);
    stepCount++;                                // Telt bij iedere kanteling eierrek steeds +1
  }

  //*************************SERIELE-MONITOR NIET GECALIBREERD******************/
  /*   Serial.println("Broedmachine Temperature IC Control");
       Serial.print("  Temperatuur...");
       sensors.requestTemperatures(); // Send the command to get temperature readings
       Serial.println("DONE");
       Serial.print("Temperature is: ");
       Serial.print(sensors.getTempCByIndex(0)); // Why "byIndex"? You can have more than one DS18B20 on the same bus.
  */
  //***************LCD-SCHERM WEL GECALIBREERD**TEMP Without DELAY************/
  sensors.requestTemperatures(); // Send the command to get temperature readings
  float RawValue = sensors.getTempCByIndex(0);
  float CorrectedValue = (((RawValue - RawLow) * ReferenceRange) / RawRange) + ReferenceLow;

  if ((unsigned long)(currentMillis - previousMillisTemp) >= intervalTemp) {
    previousMillisTemp = currentMillis;
    lcd.setCursor(0, 1);
    lcd.print("Temp = ");
    lcd.print(CorrectedValue, 1);
    lcd.print("C");
    lcd.print((char)223);

  }

  //************************Counter Teller***************************************/
  if ((unsigned long)(currentMillis - previousMillisCount) >= intervalCount)
  {
    previousMillisCount = currentMillis;
    lcd.setCursor(0, 0);
    sprintf(timeline, "%0.2d:%0.2d ", minutes, secondes);
    lcd.print(timeline);

    secondes++;

    if (secondes == 60)
    {
      secondes = 0;
      minutes ++;
    }
    if (minutes == 59)
    {
      minutes = 0;
      secondes ++;
    }

  }

  //***********************Aansturing Ledjes***********************************/
  float T = sensors.getTempCByIndex(0);   // Temperatuur sensor


  if ( T < 37.00 )    //<----------------------- Indien kouder dan 37 graden dan blauwe led, wanneer warmer dan 37,5 dan rode led, binnen de aangegeven zone dan groene led.
  {
    digitalWrite(GroeneLed, LOW);
    digitalWrite(RodeLed, LOW);
    digitalWrite(BlauweLed, HIGH);
  }
  else
  {
    if ( T > 37.50)
    {
      digitalWrite(GroeneLed, LOW);
      digitalWrite(BlauweLed, LOW);
      digitalWrite(RodeLed, HIGH);
    }
    else
    {
      digitalWrite(BlauweLed, LOW);
      digitalWrite(RodeLed, LOW);
      digitalWrite(GroeneLed, HIGH);
    }
  }

}

void rotate(int steps, float speed) {
  digitalWrite(EnablePin, LOW); //Schakelt de motor in, zodat deze beweegt wanneer daarom wordt gevraagd.

  if (steps > 0)
    if (DirectionState == LOW) {
      DirectionState = HIGH;
    } else {
      DirectionState = LOW;
    }

  speed = 1 / speed * 700; //  <---------------------Bepaal hier de draaisnelheid van de Stepper.
  steps = abs(steps); //Stores the absolute value of the content in 'steps' back into the 'steps' variable

  digitalWrite(DirectionPin, DirectionState); //Schrijft de richting naar de EasyDriver DIR-pen

  for (int i = 0; i < steps; i++) {
    digitalWrite(StepPin, HIGH);
    delayMicroseconds(speed);
    digitalWrite(StepPin, LOW);
    delayMicroseconds(speed);
  }
  digitalWrite(EnablePin, HIGH); //De motor wordt spanningsloos gemaakt tot het moment dat hij weer wordt opgeroepen.
}

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

Re: Blink without delay voor stappenmotor

Berichtdoor Koepel » 27 Nov 2018, 00:09

Het zijn een paar kleine schoonheidsfoutjes.
Is het goed als ik ze allemaal noem ? (je mag meteen doorscrollen naar de laatste alinea).

De voorkeur heeft om een pin nummer als "const int" te doen. Een #define zou per ongeluk opnieuw gedaan kunnen worden met een andere waarde.
Code: Alles selecteren
const int BlauweLedPin = 4;     //Ledpin 4 = Blauwe Led
...
const int DirectionPin = 2;                                 //Direction pin 2


Een "%d" bij een sprintf werkt samen met een "int". Je hebt nu een "signed short". Heb je dat ergens gelezen ? Gewoon een "int":
Code: Alles selecteren
int minutes, secondes;                       // Tijdsaanduiding minuten en seconden


Je hebt void setup(void) en void loop(void). Dat is helemaal goed. In de Arduino wereld wordt echter volstaan met void setup() en void loop().

In de functie setup() heb je extra blokken gemaak met '{' en '}'. Dat mag, maar hoeft niet. Je hebt er maar twee nodig, aan het begin van de functie een '{' en aan het eind een '}'. De zes daarbinnen kunnen weg.

De berekening met millis() moet met "unsigned long". Dat heb je, dat is goed. Als je dat nog eens extra gaat casten naar "unsigned long" dan lijkt het net alsof je niet begrepen hebt hoe millis() werkt.
Mijn persoonlijke voorkeur heeft daarom:
Code: Alles selecteren
if (currentMillis - previousMillisStepperMotor >= intervalStepperMotor)


In de loop() doe je iedere keer als de loop() draait een "sensors.requestTemperatures()". Mag dat zo vaak ? Dat zal dan wel :? Je doet echter op twee plaatsen een "sensors.getTempCByIndex(0)".
Daardoor staat dat niet meer netjes bij elkaar. Je zou aan het begin van de loop() dat kunnen opvragen, en die variabelen in de loop() gebruiken. Met een nette kop van commentaar kun je zo een afzonderlijk stukje code maken voor de temperatuur opvragen.

Er bestaat een "zeef"-methode voor het stukje code van 37.0 en 37.5 graden.
Stel dat je grind aan het zeven bent, en je hebt verschillende zeven onder elkaar. De grove zeef gaat boven voor de grote stenen, en naar beneden toe worden de zeven steeds fijner. Dat kan ook in code.
Je hebt grove stenen van onder de 37 graden, gewone stenen tussen de 37 en 37.5 graden, en kleine steentjes van boven de 37.5 graden.
Code: Alles selecteren
  // Indien kouder dan 37 graden dan blauwe led,
  // wanneer warmer dan 37,5 dan rode led,
  // binnen de aangegeven zone dan groene led.
  if( T < 37.00)        // kouder dan 37 graden
  {
    digitalWrite(GroeneLed, LOW);
    digitalWrite(RodeLed, LOW);
    digitalWrite(BlauweLed, HIGH);
  }
  else if( T < 37.5)   // tussen 37 en 37.5 graden
  {
    digitalWrite(BlauweLed, LOW);
    digitalWrite(RodeLed, LOW);
    digitalWrite(GroeneLed, HIGH);
  }
  else                  // warmer dan 37.5 graden
  {
    digitalWrite(GroeneLed, LOW);
    digitalWrite(BlauweLed, LOW);
    digitalWrite(RodeLed, HIGH);
  }


Een minuut duurt bij jou maar 59 seconden ? :lol: en dat corrigeer je door er een seconde bij op te tellen :roll:
Dit lijkt me veiliger:
Code: Alles selecteren
secondes++;

if (secondes >= 60)
{
  secondes = 0;
  minutes++;

  if (minutes >= 60)
  {
    minutes = 0;
  }
}


In de functie rotate() heeft het eerste if-statement geen '{' en '}'. In de taal 'C++' mag dat en ik gebruik het zelf ook. Maar omdat daarbinnen weer een if-statement staat, ziet het er lelijk uit. Mag die "if (steps > 0)" ook een '{' en '}' ?

De code "speed = 1 / speed * 700" kan verwarrend zijn. De "1" en "700" zijn integers voor de compiler. Je kunt voor de compiler en voor jezelf nog eens extra aangeven dat het floating point getallen zijn door dit:
Code: Alles selecteren
speed = 1.0 / speed * 700.0;


Een punt voor integers in de sprintf format string ? Die punt is hier niet nodig. Je kunt dit doen:
Code: Alles selecteren
sprintf(timeline, "%02d:%02d ", minutes, secondes)
Aanvulling: Ik zit nog even te lezen, en het is toegestaan. Het is echter niet gebruikelijk om een "precision" bij integers op te geven. De "%02d" is meer gebruikelijk en heeft hetzelfde resultaat. http://www.cplusplus.com/reference/cstdio/printf/

Volg je het nog, want nu komt het pas :mrgreen: :!:
Wanneer je iets iedere seconde doet, maar er een delay in de code zit, dan zal de volgende keer dat millis() wordt opgevraagd dat verder in de tijd liggen. Dus "currentMillis = millis()" zal dan de volgende keer wat later zijn. Als die vertraging net op hetzelfde moment gebeurt dat de tijd van de interval om is, dan zal de interval iets langer duren. Alles schuift dus op, verder in de tijd.
Dat is normaal gesproken ook de bedoeling, want dan raakt de code niet met zichzelf in de knoop. De enige uitzondering is als je een klok wilt bijhouden.
Om je strikt vast te houden aan de tijd kun je dit doet:
Code: Alles selecteren
if (currentMillis - previousMillisCount >= intervalCount)
{
  previousMillisCount += intervalCount;     // blijf exact in de pas met de tijd
  ...
Dan wordt het precies op de seconde uitgevoerd. Zelfs als er een delay van meer dan een seconde in de code zit, dan wordt het ingehaald totdat de het weer in de pas loopt. Het gaat nooit scheef lopen en er raakt nooit een seconde kwijt.

Volgende

Terug naar Arduino software

Wie is er online?

Gebruikers in dit forum: Geen geregistreerde gebruikers en 4 gasten