Zonnetracker vollop benut

[Gompy Profiel Privébericht]

@ shooter, ik heb een miniatuur test opstelling van het zonnepaneel op mijn bureau en het echte zonnepaneel buiten in de tuin.
Daar zitten verschillende displays aan dus vandaar BLUE en GREEN, zo kan ik snel omschakelen door alleen de // aan te passen.
Het vertalen naar het Nederlands is van latere zorg, eerst wil ik het programma met zo min mogelijk en begrijpelijke wijzigen aanpassen.
Als beginner moet ik beetje bij beetje wijzen zonder dat ik de hele sketch moet veranderen en de draad kwijt raak.

Ik heb al eea in de bestaan de sketch aangepast met de hysteresis alleen staat het nog tussen */ en /* omdat ik nog niet inzie hoe ik A0 vertaal naar dv of dh, is gemiddelde waarde horizontale- en verticale LDR's.
Ook met const en enum ben ik onbekend, dus dat moet ik ook opzoeken wat dat is en doet.

PS, vergeet nog even de "voids" die tussen de */ en /* staan, die zijn voor mij om te begrijpen in welk deel ze moeten staan.

Code: Alles selecteren

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// LiquidCrystal_I2C lcd(0x27,20,4); // LCD BLUE
LiquidCrystal_I2C lcd(0x3F,20,4); // LCD GREEN

/*
// set hysteresis

// This assumes a photoresistor is pulling A0 up and a resistor is pulling A0 down
// When the input is bright, the voltage increases, when dark, the voltage decreases.
const int INPUT_PIN = A0;


// Global variables.

// The state of the system can be captured with only two values, e.g., it is represented as a single bit.
// The following statement defines two symbolic values, one for each possible state.
enum state_t { IS_DARK, IS_LIGHT };

// Declare the state variable as a symbolic value.
enum state_t state = IS_DARK;

// The hysteretic response is defined by using two thresholds. 
const int light_threshold = 700;
const int dark_threshold  = 500;

*/

// motor azimuth
int in1 = 9;  // D9 output to in1 L298N module
int in2 = 10; // D10 output to in2 L298N module

// motor elevation
int in3 = 11; // D11 output to in3 L298N module
int in4 = 12; // D12 output to in4 L298N module

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

  lcd.init(); // initialize the lcd
  lcd.backlight(); // ON
 
/*

void setup() 
{
// configure our trivial I/O
  pinMode( LED_BUILTIN, OUTPUT );

// the LED start out ON to match the initial state
  digitalWrite(LED_BUILTIN, HIGH);
}
*/

}

void loop()
{
 
// control delay time in milliseconds of LIGHT SENSOR readings
  int delaytime = analogRead(A7)*29.326 ; // 30.000 milliseconds wait befor next_loop
  int next_loop = map(analogRead(A7), 1023, 0, 30, 0); // set range time 30 sec to LCD

// set range of tolerance between LIGHT SENSOR readings
  int tolerance = analogRead(A6)/20.48; // difference 50 between sensors reading

// LDR LIGHT SENSORS
  int tr = analogRead(A0); // LDR top right
  int br = analogRead(A1); // LDR bottom right
  int tl = analogRead(A2); // LDR top left
  int bl = analogRead(A3); // LDR bottom left
 
// set average values LDR's
  int avt = (tr + tl) / 2; // average top value
  int avb = (bl + br) / 2; // average down value
  int avl = (tl + bl) / 2; // average left value
  int avr = (tr + br) / 2; // average right value

// set average value vertical and horizontal
  int dv = avt - avb; // average top and bottom value
  int dh = avl - avr; // average left and right value

//print values for serial monitor debugging
  Serial.println("********************");
  Serial.print("Top Left\t");
  Serial.print(tl);
  Serial.println(); 
  Serial.print("Top Right\t");   
  Serial.print(tr);
  Serial.println(); 
  Serial.print("Bottom Left\t");
  Serial.print(bl);
  Serial.println(); 
  Serial.print("Bottom Right\t"); 
  Serial.print(br);
  Serial.println();
  Serial.println();
  Serial.print("Delaytime sec\t");
  Serial.print(next_loop);
  Serial.println();
  Serial.println(); 
  Serial.print("Tolerance\t"); 
  Serial.print(tolerance);
  Serial.println();
  Serial.println(); 
  Serial.print("+UP<>DOWN-\t");
  Serial.print(dv); 
  Serial.println(); 
  Serial.print("AVT - up\t");
  Serial.print(avt);
  Serial.println();
  Serial.print("AVB - down\t");   
  Serial.print(avb);
  Serial.println();
  Serial.println();
  Serial.print("+WEST<>EAST-\t");
  Serial.print(dh);
  Serial.println();
  Serial.print("AVL - west\t");     
  Serial.print(avl);
  Serial.println();
  Serial.print("AVR - east\t");     
  Serial.print(avr);
  Serial.println();
  Serial.println();

/*

void loop()
{
  // Read the ambient light level.
  int input = analogRead(INPUT_PIN);

  if (state == IS_LIGHT) {
    if (input < dark_threshold) {
      Serial.print("Dark observed at input level ");
      Serial.println(input);
      Serial.println("Transitioning to the IS_DARK state.");
     
      state = IS_DARK;
      digitalWrite(LED_BUILTIN, HIGH);
    }

  } else { // state must be IS_DARK
    if (input > light_threshold) {
      Serial.print("Light observed at input level ");
      Serial.println(input);
      Serial.println("Transitioning to the IS_LIGHT state.");
     
      state = IS_LIGHT;
      digitalWrite(LED_BUILTIN, LOW);
    }
  }
}

*/ 
 
  if (-1*tolerance > dv || dv > tolerance) // check if the difference in top/bottom LIGHT SENSORS is greater than tolerance
{
  if (avt < avb) // if average LIGHT SENSOR values on top side are smaller than on bottom side then elevation motor rotates CLOCKWISE
  {
// set motor Elevation down
  digitalWrite(in3, HIGH);
  digitalWrite(in4, LOW);
  Serial.println("ELEVATION MOTOR DOWN");
  lcd.setCursor(0,0);
  lcd.print("ELEVATION :  DOWN "); // print lcd row 1
  }
  else // if average LIGHT SENSOR values on bottom side are greater than on top side then elevation motor rotates COUNTERCLOCKWISE
  {
// set motor Elevation up
  digitalWrite(in3, LOW);
  digitalWrite(in4, HIGH);
  Serial.println("ELEVATION MOTOR UP");
  lcd.setCursor(0,0);
  lcd.print("ELEVATION :    UP ");// print lcd row 1
  }
}
  else if (-1*tolerance < dv || dv < tolerance) // if difference is smaller than tolerance, STOP elevation motor
  {
// stop Elevation motor
  digitalWrite(in3, LOW);
  digitalWrite(in4, LOW);
  Serial.println("ELEVATION MOTOR STOP"); 
  lcd.setCursor(0,0);
  lcd.print("ELEVATION :  STOP "); // print lcd row 1

// Elevation moves down at night
  if ((avt < 700) && (avb < 700))
  {
  digitalWrite(in3, HIGH);
  digitalWrite(in4, LOW);
  Serial.println("ELEVATION MOTOR NIGHT"); 
  lcd.setCursor(0,0);
  lcd.print("ELEVATION :  NIGHT"); // print lcd row 1
  }
}

  if (-1*tolerance > dh || dh > tolerance) // check if the difference in left and right LIGHT SENSORS is within tolerance range
 {
  if (avr < avl) // if average LIGHT SENSOR values on left side are greater than right side, azimuth motor rotates CLOCKWISE
  {
// set motor Azimuth west / left
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
  Serial.println("AZIMUTH   MOTOR WEST");
  lcd.setCursor(0,1);
  lcd.print("AZIMUTH   :  WEST "); // print lcd row 2
  }
   else // if average LIGHT SENSOR values on right side are greater than on left side, azimuth motor rotates COUNTERCLOCKWISE
  {
// set motor Azimuth east / right
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
  Serial.println("AZIMUTH   MOTOR EAST");
  lcd.setCursor(0,1);
  lcd.print("AZIMUTH   :  EAST "); // print lcd row 2
  }
 }
  else if (-1*tolerance < dh || dh < tolerance) //if difference is smaller than tolerance, STOP azimuth motor
  {
// stop motor Azimuth
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW);
  Serial.println("AZIMUTH   MOTOR STOP");
  lcd.setCursor(0,1);
  lcd.print("AZIMUTH   :  STOP "); // print lcd row 2
  }

// Azimuth moves east at night / right
  if ((avr < 700) && (avl < 700))
  {
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
  Serial.println("AZIMUTH   MOTOR NIGHT");
  lcd.setCursor(0,1);
  lcd.print("AZIMUTH   :  NIGHT"); // print lcd row 2
  }
 
// print lcd delaytime row 3
  lcd.setCursor(0,2);
  lcd.print("DELAY     :  ");
  char temp[5]; // enough room for 4 numbers
  snprintf(temp,6, "%4d", (delaytime/1000)); // %4d = 4 digits, right aligned
  lcd.print(temp);
  lcd.setCursor(18, 2); // original 18
  lcd.print("s"); // time in seconds
  {
// print lcd sensitive row 4
  lcd.setCursor(0,3);
  lcd.print("TOLERANCE : ");
  char temp1[5]; // enough room for4 numbers
  snprintf(temp1,6, "%5d", tolerance); // %4d = 4 digets, right aligned
  lcd.print(temp1);
  lcd.setCursor(18, 3);
  lcd.print("+-");

  delay(delaytime);

  }
}

void print2digits(int number)
{
  if (number >= 0 && number < 10)
  {
    Serial.write('0');
  }
  Serial.print(number);
}


[Gij Kieken Profiel]

Je zou bijvoorbeeld int dv in jouw loop kunnen gebruiken.

In plaats van potmeterWaarde bijvoorbeeld schemerWaarde.
Ter vervanging van A0 het volgende,

Dus int schemerWaarde = int dv //Dit is omslachtig en kan anders maar de bedoeling is om betekenis te geven aan varaibelen
Met enum geef je ook op een betere manier betekenis aan variabelen in plaats van 1 en 0 of hoog en laag.
Tik in google of je favoriete browser c++ enum


//Lees de waarde van de potmeter
int potmeterWaarde = analogRead(INPUT_PIN);
/*Verander hier potmeterWaarde in een voor jouw beter geschikte naam
en stel die gelijk aan jouw gemiddelde LDR waardes
gebruik uiteraard jouw variabele naam verder in de sketch
De variabele myDayState kun je gebruiken als een reeds eerder
vermelde vlag

[Gij Kieken Profiel]

Shooter was al goed op weg maar jij moet het afwerken,

Code: Alles selecteren

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
 
// LiquidCrystal_I2C lcd(0x27,20,4); // LCD BLUE weghalen als het niet nodig is
LiquidCrystal_I2C lcd(0x3F, 20, 4); // LCD GREEN
 
// motor azimuth
int PinMotorLinks = 9;  // D9 output to in1 L298N module even gesteld dat dit links is verander dan overal in1 naar PinMotorLinks
int PinMotorRechts = 10; // D10 output to in2 L298N module // en de andere natuurlijk ook dus PinMotorRechts
// motor elevation
int PinMotorOmhoog = 11; // D11 output to in3 L298N module PinMotorOmhoog
int PinMotorOmlaag = 12; // D12 output to in4 L298N module PinMotorOmlaag
int PinSensorTopRechts = A0;
int PinSensorOnderRechts = A1;
int PinSensorTopLinks = A2;
int PinSensorOnderLinks = A3;// de rest even zelf doen
// dat maakt het allemaal leesbaar, en wij snappen het dan ook
int tl;
int tr;
int bl;
int br;
int next_loop;
int tolerance;
int dv;
int dh;
int avt;
int avl;
int avr;
int avd;

enum dayState { NACHT, DAG};      //Eigelijk zijn dit constant int,NACHT=0 en DAG=1
enum dayState myDayState = NACHT; //Declareer de status van de variabele
const int dag_drempel = 700;      //Kantelpunt voor DAG modus,bepaal zelf de waarde
const int nacht_drempel = 300;    //Kantelpunt voor NACHT modus,bepaal zelf de waarde
 
void setup()
{
  Serial.begin(9600); // initialize the serial port
 
  lcd.init(); // initialize the lcd
  lcd.backlight(); // ON
  // ik mis de pinMode voor de uitgangen
  pinMode (PinMotorLinks, OUTPUT); //
  pinMode (PinMotorRechts, OUTPUT);
  pinMode (PinMotorOmhoog, OUTPUT);
  pinMode (PinMotorOmlaag, OUTPUT);
  pinMode (PinSensorTopLinks, INPUT);
  pinMode (PinSensorTopRechts, INPUT);
  pinMode (PinSensorOnderLinks, INPUT);
  pinMode (PinSensorOnderRechts, INPUT);
  // hier ook toevoegen
  pinMode(LED_BUILTIN, OUTPUT);
  //We starten met de LED Aan
  digitalWrite(LED_BUILTIN , HIGH);

}
 
void loop()
{
  // LDR LIGHT SENSORS de rest even zelf veranderen dus tr is TopRechts
  int tr = analogRead(PinSensorTopRechts); // LDR top right
  int br = analogRead(PinSensorOnderRechts); // LDR bottom right
  int tl = analogRead(PinSensorTopLinks); // LDR top left
  int bl = analogRead(PinSensorOnderLinks); // LDR bottom left
 
  // control delay time in milliseconds of LIGHT SENSOR readings - Arduino LED indicate time
  // Input A7 0 till 5 Volt
  int delaytime = analogRead(A7) * 29.326 ; // 30 seconds wait befor next_run
  // set range for read time 30 sec display
  int next_loop = map(analogRead(A7), 1023, 0, 30, 0);
 
  // set range of tolerance between LIGHT SENSOR readings
  // Input A6 0 till 5 Volt
  int tolerance = analogRead(A6) / 20.48; // difference 50 between sensors
 
  // set average values LDR's
  int avt = (tr + tl) / 2; // average value top
  int avd = (bl + br) / 2; // average value down
  int avl = (tl + bl) / 2; // average value left
  int avr = (tr + br) / 2; // average value right
  // average difference of top and bottom LIGHT SENSORS
  int dv = avt - avd; // hier staat dus het verschil boven en onder prima
  // average difference of left and right LIGHT SENSORS
  int dh = avl - avr;

  //Lees de waarde van de LDR's
  int schemerWaarde = dv;
  /*Verander hier potmeterWaarde in een voor jouw beter geschikte naam
    en stel die gelijk aan jouw gemiddelde LDR waardes
    gebruik uiteraard jouw variabele naam verder in de sketch
    De variabele myDayState kun je gebruiken als een reeds eerder
    vermelde vlag
   
    Verder in jouw sketch waar nodig zet je dan
    if (myDayState == DAG) { //Is het Dag?
    doe je code, zoals motors laten draaien etc...
    }

    en waar nodig als het Nacht is
    if (myDayState == NACHT) { //Is het Nacht?
    doe je code, zoals motors laten draaien etc...
    }   
   
  */

  if (myDayState == DAG) { //Is het Dag?
    if (schemerWaarde < nacht_drempel) {
      Serial.print("De Nacht is gevallen ");
      Serial.println(schemerWaarde);
      Serial.println("Er is een overgang van Dag naar Nacht status.");

      myDayState = NACHT;//Dit is een zogenaamde vlag die verder kunt gebruiken
      digitalWrite(LED_BUILTIN, HIGH);//Het is Nacht de Led is Aan
    }
  } else { //Het moet nu Nacht zijn
    if (schemerWaarde > dag_drempel) {
      Serial.print("De zon komt op ");
      Serial.println(schemerWaarde);
      Serial.println("Er is een overgang van Nacht naar Dag status.");

      myDayState = DAG;//Dit is een vlag die verder kunt gebruiken
      digitalWrite(LED_BUILTIN , LOW);//Schakel de Led Uit het is Dag
    }
  } 



  //  hier een functie voor het printen
  printen();
  if ((avr < 700) && (avl < 700))  // sensorvalue
  {
    digitalWrite(PinMotorLinks, LOW);
    digitalWrite(PinMotorRechts, HIGH);
    Serial.println("AZIMUTH   MOTOR NIGHT");
    lcd.setCursor(0, 1);
    lcd.print("AZIMUTH   :  NIGHT"); // print lcd row 2
  }
 
  if (-1 * tolerance > dv || dv > tolerance) // check difference in top/bottom LIGHT SENSORS is greater than tolerance
  {
    // change direction motor with < and >
    if (avt < avd) // if average LIGHT SENSOR values on top side are smaller than on bottom side then elevation motor rotates CLOCKWISE
    {
      // set motor Elevation down
      digitalWrite(PinMotorOmhoog, HIGH);
      digitalWrite(PinMotorOmlaag, LOW);
      Serial.println("ELEVATION MOTOR DOWN");
      lcd.setCursor(0, 0);
      lcd.print("ELEVATION :  DOWN "); // print lcd row 1
    }
    else // if average LIGHT SENSOR values on bottom side are greater than on top side then elevation motor rotates COUNTERCLOCKWISE
    {
      // set motor Elevation up
      digitalWrite(PinMotorOmhoog, LOW);
      digitalWrite(PinMotorOmlaag, HIGH);
      Serial.println("ELEVATION MOTOR UP");
      lcd.setCursor(0, 0);
      lcd.print("ELEVATION :    UP ");// print lcd row 1
    }
  }
  else if (-1 * tolerance < dv || dv < tolerance) // if difference is smaller than tolerance, STOP elevation motor
  {
    // stop Elevation motor
    digitalWrite(PinMotorOmhoog, LOW);
    digitalWrite(PinMotorOmlaag, LOW);
    Serial.println("ELEVATION MOTOR STOP");
    lcd.setCursor(0, 0);
    lcd.print("ELEVATION :  STOP "); // print lcd row 1
 
    // Elevation moves down at night
    if ((avt < 700) && (avd < 700)) // sensor value
    {
      digitalWrite(PinMotorOmhoog, HIGH);
      digitalWrite(PinMotorOmlaag, LOW);
      Serial.println("ELEVATION MOTOR NIGHT");
      lcd.setCursor(0, 0);
      lcd.print("ELEVATION :  NIGHT"); // print lcd row 1
    }
  }
 
  if (-1 * tolerance > dh || dh > tolerance) // check difference in left and right LIGHT SENSORS is within tolerance range
  {
    // change direction motor with < and >
    if (avr < avl) // if average LIGHT SENSOR values on left side are greater than right side, azimuth motor rotates CLOCKWISE
    {
      // set motor Azimuth west / left
      digitalWrite(PinMotorLinks, HIGH);
      digitalWrite(PinMotorRechts, LOW);
      Serial.println("AZIMUTH   MOTOR WEST");
      lcd.setCursor(0, 1);
      lcd.print("AZIMUTH   :  WEST "); // print lcd row 2
    }
    else // if average LIGHT SENSOR values on right side are greater than on left side, azimuth motor rotates COUNTERCLOCKWISE
    {
      // set motor Azimuth east / right
      digitalWrite(PinMotorLinks, LOW);
      digitalWrite(PinMotorRechts, HIGH);
      Serial.println("AZIMUTH   MOTOR EAST");
      lcd.setCursor(0, 1);
      lcd.print("AZIMUTH   :  EAST "); // print lcd row 2
    }
  }
  else if (-1 * tolerance < dh || dh < tolerance) //if difference is smaller than tolerance, STOP azimuth motor
  {
    // stop motor Azimuth
    digitalWrite(PinMotorLinks, LOW);
    digitalWrite(PinMotorRechts, LOW);
    Serial.println("AZIMUTH   MOTOR STOP");
    lcd.setCursor(0, 1);
    lcd.print("AZIMUTH   :  STOP "); // print lcd row 2
  }
 
  // Azimuth moves east at night / right
 
  // print lcd delaytime row 3
  lcd.setCursor(0, 2);
  lcd.print("DELAY     :  ");
  char temp[5]; // enough room for 4 numbers
  snprintf(temp, 6, "%4d", (delaytime / 1000)); // %4d = 4 digits, right aligned
  lcd.print(temp);
  lcd.setCursor(18, 2); // original 18
  lcd.print("s"); // time in seconds
  {
    // print lcd sensitive row 4
    lcd.setCursor(0, 3);
    lcd.print("TOLERANCE : ");
    char temp1[5]; // enough room for4 numbers
    snprintf(temp1, 6, "%5d", tolerance); // %4d = 4 digets, right aligned
    lcd.print(temp1);
    lcd.setCursor(18, 3);
    lcd.print("+-");
 
    delay(delaytime);
 
  }
}
 
void print2digits(int number)
{
  if (number >= 0 && number < 10)
  {
    Serial.write('0');
  }
  Serial.print(number);
}
void printen () { //print values to serial monitor for debugging
  Serial.println("********************");
  Serial.print("Top Left\t");
  Serial.print(tl);
  Serial.println();
  Serial.print("Top Right\t");
  Serial.print(tr);
  Serial.println();
  Serial.print("Bottom Left\t");
  Serial.print(bl);
  Serial.println();
  Serial.print("Bottom Right\t");
  Serial.print(br);
  Serial.println();
  Serial.println();
  Serial.print("Delaytime sec\t");
  Serial.print(next_loop);
  Serial.println();
  Serial.println();
  Serial.print("Tolerance\t");
  Serial.print(tolerance);
  Serial.println();
  Serial.println();
  Serial.print("+UP<>DOWN-\t");
  Serial.print(dv);
  Serial.println();
  Serial.print("AVT - up\t");
  Serial.print(avt);
  Serial.println();
  Serial.print("AVD - down\t");
  Serial.print(avd);
  Serial.println();
  Serial.println();
  Serial.print("+WEST<>EAST-\t");
  Serial.print(dh);
  Serial.println();
  Serial.print("AVL - west\t");
  Serial.print(avl);
  Serial.println();
  Serial.print("AVR - east\t");
  Serial.print(avr);
  Serial.println();
  Serial.println();
}


Vervolgens moet je waar nodig de vlag gebruiken en laten zien wat je zelf gedaan hebt,

[shooter Profiel Privébericht]

zo ik heb er weer een paar regels bijgezet tussen de regels van jou en koepel in trouwens kijk er eens naar.
staat trouwens ook een timer in om te printen , zelf de delay eruit halen.
cpp code

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// LiquidCrystal_I2C lcd(0x27,20,4); // LCD BLUE weghalen als het niet nodig is
LiquidCrystal_I2C lcd(0x3F, 20, 4); // LCD GREEN

// motor azimuth
int PinMotorLinks = 9;  // D9 output to in1 L298N module even gesteld dat dit links is verander dan overal in1 naar PinMotorLinks
int PinMotorRechts = 10; // D10 output to in2 L298N module // en de andere natuurlijk ook dus PinMotorRechts
// motor elevation
int PinMotorOmhoog = 11; // D11 output to in3 L298N module PinMotorOmhoog
int PinMotorOmlaag = 12; // D12 output to in4 L298N module PinMotorOmlaag
int PinSensorTopRechts = A0;
int PinSensorOnderRechts = A1;
int PinSensorTopLinks = A2;
int PinSensorOnderLinks = A3;// de rest even zelf doen
// dat maakt het allemaal leesbaar, en wij snappen het dan ook
int tl; // hier dus ook langere namen zetten zoals bovenrechts etc.
int tr;// dan kun je met CTRL F alles vervangen
int bl;
int br;
int next_loop;
int tolerance;
int dv;
int dh;
int avt;
int avl;
int avr;
int avd;
long unsigned printtijd;
long unsigned printdelay=5000;
enum dayState { NACHT, DAG};      //Eigelijk zijn dit constant int,NACHT=0 en DAG=1
enum dayState myDayState = NACHT; //Declareer de status van de variabele
// deze enum snap ik niet
const int dag_drempel = 700;      //Kantelpunt voor DAG modus,bepaal zelf de waarde
const int nacht_drempel = 300;    //Kantelpunt voor NACHT modus,bepaal zelf de waarde

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

  lcd.init(); // initialize the lcd
  lcd.backlight(); // ON
  // ik mis de pinMode voor de uitgangen
  pinMode (PinMotorLinks, OUTPUT); //
  pinMode (PinMotorRechts, OUTPUT);
  pinMode (PinMotorOmhoog, OUTPUT);
  pinMode (PinMotorOmlaag, OUTPUT);
  pinMode (PinSensorTopLinks, INPUT);
  pinMode (PinSensorTopRechts, INPUT);
  pinMode (PinSensorOnderLinks, INPUT);
  pinMode (PinSensorOnderRechts, INPUT);
  // hier ook toevoegen
  pinMode(LED_BUILTIN, OUTPUT);
  //We starten met de LED Aan
  digitalWrite(LED_BUILTIN , HIGH);
  // ledje gaat aan
}

void loop()
{
  // LDR LIGHT SENSORS de rest even zelf veranderen dus tr is TopRechts
  // ik schrijf er pin voor dan weet ik dat het een fysiek ding is
  int tr = analogRead(PinSensorTopRechts); // LDR top right
  int br = analogRead(PinSensorOnderRechts); // LDR bottom right
  int tl = analogRead(PinSensorTopLinks); // LDR top left
  int bl = analogRead(PinSensorOnderLinks); // LDR bottom left

  // control delay time in milliseconds of LIGHT SENSOR readings - Arduino LED indicate time
  // Input A7 0 till 5 Volt
  int delaytime = analogRead(A7) * 29.326 ; // max 30 seconds wait befor next_run
  // set range for read time 30 sec display
  int next_loop = map(analogRead(A7), 1023, 0, 30, 0);
  // delaytime en next_loopzijn verschillend maar komen op hetzelfde neer maar worden verschillend berekend?

  // set range of tolerance between LIGHT SENSOR readings
  // Input A6 0 till 5 Volt
  int tolerance = analogRead(A6) / 20.48; // difference 50 between sensors
  //  de grenzen zijn dus 0 en 50 ?

  // set average values LDR's
  int avt = (tr + tl) / 2; // average value top
  int avd = (bl + br) / 2; // average value down
  int avl = (tl + bl) / 2; // average value left
  int avr = (tr + br) / 2; // average value right
  // average difference of top and bottom LIGHT SENSORS
  int dv = avt - avd; // hier staat dus het verschil boven en onder prima
  // average difference of left and right LIGHT SENSORS
  int dh = avl - avr;

  //Lees de waarde van de LDR's
  int schemerWaarde = dv;
  /*Verander hier potmeterWaarde in een voor jouw beter geschikte naam
    en stel die gelijk aan jouw gemiddelde LDR waardes
    gebruik uiteraard jouw variabele naam verder in de sketch
    De variabele myDayState kun je gebruiken als een reeds eerder
    vermelde vlag

    Verder in jouw sketch waar nodig zet je dan
    if (myDayState == DAG) { //Is het Dag?
    doe je code, zoals motors laten draaien etc...
    }

    en waar nodig als het Nacht is
    if (myDayState == NACHT) { //Is het Nacht?
    doe je code, zoals motors laten draaien etc...
    }

  */
  if (myDayState == DAG) { //Is het Dag?
    if (schemerWaarde < nacht_drempel) {
      Serial.print("De Nacht is gevallen ");
      Serial.println(schemerWaarde);
      Serial.println("Er is een overgang van Dag naar Nacht status.");

      myDayState = NACHT;//Dit is een zogenaamde vlag die verder kunt gebruiken
      digitalWrite(LED_BUILTIN, HIGH);//Het is Nacht de Led is Aan
    }
  } else { //Het moet nu Nacht zijn
    if (schemerWaarde > dag_drempel) {
      Serial.print("De zon komt op ");
      Serial.println(schemerWaarde);
      Serial.println("Er is een overgang van Nacht naar Dag status.");

      myDayState = DAG;//Dit is een vlag die verder kunt gebruiken
      digitalWrite(LED_BUILTIN , LOW);//Schakel de Led Uit het is Dag
    }
  }
  //  hier een functie voor het printen
  if (millis()-printtijd>printdelay){
    printtijd=millis();
    printen();}
  if ((avr < dag_drempel) && (avl < dag_drempel))  // schemerwaarde
    // ik zou er maar een pakken want de andere is dan ook in die buurt
  {
    digitalWrite(PinMotorLinks, LOW);
    digitalWrite(PinMotorRechts, HIGH);
    Serial.println("AZIMUTH   MOTOR NIGHT");
    lcd.setCursor(0, 1);
    lcd.print("AZIMUTH   :  NIGHT"); // print lcd row 2
  }
  else
  {
    // ik zou ze hier al uit elkaar halen dus vier richtingen dus if -1*tolerance >dv is een richting
    // dan een kant op en zo 4 keer.
    // dan heb je er ook geen else meer in staan wat goed is voor de leesbaarheid

    if (-1 * tolerance > dv || dv > tolerance) // check difference in top/bottom LIGHT SENSORS is greater than tolerance
    {
      // change direction motor with < and >
      if (avt < avd) // if average LIGHT SENSOR values on top side are smaller than on bottom side then elevation motor rotates CLOCKWISE
      {
        // set motor Elevation down
        digitalWrite(PinMotorOmhoog, HIGH);
        digitalWrite(PinMotorOmlaag, LOW);
        Serial.println("ELEVATION MOTOR DOWN");
        lcd.setCursor(0, 0);
        lcd.print("ELEVATION :  DOWN "); // print lcd row 1
      }
      else // if average LIGHT SENSOR values on bottom side are greater than on top side then elevation motor rotates COUNTERCLOCKWISE
      {
        // set motor Elevation up
        digitalWrite(PinMotorOmhoog, LOW);
        digitalWrite(PinMotorOmlaag, HIGH);
        Serial.println("ELEVATION MOTOR UP");
        lcd.setCursor(0, 0);
        lcd.print("ELEVATION :    UP ");// print lcd row 1
      }
    }
    else if (-1 * tolerance < dv || dv < tolerance) // if difference is smaller than tolerance, STOP elevation motor
    {
      // stop Elevation motor
      digitalWrite(PinMotorOmhoog, LOW);
      digitalWrite(PinMotorOmlaag, LOW);
      Serial.println("ELEVATION MOTOR STOP");
      lcd.setCursor(0, 0);
      lcd.print("ELEVATION :  STOP "); // print lcd row 1

      // Elevation moves down at night
      if ((avt < 700) && (avd < 700)) // sensor value
      {
        digitalWrite(PinMotorOmhoog, HIGH);
        digitalWrite(PinMotorOmlaag, LOW);
        Serial.println("ELEVATION MOTOR NIGHT");
        lcd.setCursor(0, 0);
        lcd.print("ELEVATION :  NIGHT"); // print lcd row 1
      }
    }

    if (-1 * tolerance > dh || dh > tolerance) // check difference in left and right LIGHT SENSORS is within tolerance range
    {
      // change direction motor with < and >
      if (avr < avl) // if average LIGHT SENSOR values on left side are greater than right side, azimuth motor rotates CLOCKWISE
      {
        // set motor Azimuth west / left
        digitalWrite(PinMotorLinks, HIGH);
        digitalWrite(PinMotorRechts, LOW);
        Serial.println("AZIMUTH   MOTOR WEST");
        lcd.setCursor(0, 1);
        lcd.print("AZIMUTH   :  WEST "); // print lcd row 2
      }
      else // if average LIGHT SENSOR values on right side are greater than on left side, azimuth motor rotates COUNTERCLOCKWISE
      {
        // set motor Azimuth east / right
        digitalWrite(PinMotorLinks, LOW);
        digitalWrite(PinMotorRechts, HIGH);
        Serial.println("AZIMUTH   MOTOR EAST");
        lcd.setCursor(0, 1);
        lcd.print("AZIMUTH   :  EAST "); // print lcd row 2
      }
    }
    else if (-1 * tolerance < dh || dh < tolerance) //if difference is smaller than tolerance, STOP azimuth motor
    {
      // stop motor Azimuth
      digitalWrite(PinMotorLinks, LOW);
      digitalWrite(PinMotorRechts, LOW);
      Serial.println("AZIMUTH   MOTOR STOP");
      lcd.setCursor(0, 1);
      lcd.print("AZIMUTH   :  STOP "); // print lcd row 2
    }
    // Azimuth moves east at night / right

    // print lcd delaytime row 3
  }
  lcd.setCursor(0, 2);
  lcd.print("DELAY     :  ");
  char temp[5]; // enough room for 4 numbers
  snprintf(temp, 6, "%4d", (delaytime / 1000)); // %4d = 4 digits, right aligned
  lcd.print(temp);
  lcd.setCursor(18, 2); // original 18
  lcd.print("s"); // time in seconds
  // print lcd sensitive row 4
  lcd.setCursor(0, 3);
  lcd.print("TOLERANCE : ");
  char temp1[5]; // enough room for4 numbers
  snprintf(temp1, 6, "%5d", tolerance); // %4d = 4 digets, right aligned
  lcd.print(temp1);
  lcd.setCursor(18, 3);
  lcd.print("+-");

  delay(delaytime); // dan gebeurt er niks ofwel motoren blijven doordraaien
  // al dat printen kan veel beter met een timer in een aparte functie
}


void print2digits(int number)
{
  if (number >= 0 && number < 10)
  {
    Serial.write('0');
  }
  Serial.print(number);
}
void printen () { //print values to serial monitor for debugging
  Serial.println("********************");
  Serial.print("Top Left\t");
  Serial.print(tl);
  Serial.println();
  Serial.print("Top Right\t");
  Serial.print(tr);
  Serial.println();
  Serial.print("Bottom Left\t");
  Serial.print(bl);
  Serial.println();
  Serial.print("Bottom Right\t");
  Serial.print(br);
  Serial.println();
  Serial.println();
  Serial.print("Delaytime sec\t");
  Serial.print(next_loop);
  Serial.println();
  Serial.println();
  Serial.print("Tolerance\t");
  Serial.print(tolerance);
  Serial.println();
  Serial.println();
  Serial.print("+UP<>DOWN-\t");
  Serial.print(dv);
  Serial.println();
  Serial.print("AVT - up\t");
  Serial.print(avt);
  Serial.println();
  Serial.print("AVD - down\t");
  Serial.print(avd);
  Serial.println();
  Serial.println();
  Serial.print("+WEST<>EAST-\t");
  Serial.print(dh);
  Serial.println();
  Serial.print("AVL - west\t");
  Serial.print(avl);
  Serial.println();
  Serial.print("AVR - east\t");
  Serial.print(avr);
  Serial.println();
  Serial.println();
}

[Gompy Profiel Privébericht]

OK.......je zadelt me wel op met een hoop huiswerk

De sketch moet ik eens goed doorlezen want er zijn wel een hoop veranderingen / aanpassingen.
Ik denk er over om de gehele sketch opnieuw te gaan schrijven want met al die veranderingen in de bestaande sketch zal het er niet beter op worden heb ik het gevoel.
Zoals ik al heb ondervonden is de basis niet goed, die is onstabiel.....niet hoe ik meet, maar de manier van uitvoeren.

Het probleem zit eigenlijk in de steeds wisselende waarden en de korte meettijd heb ik nu ondervonden.
De sensoren meten een waarde, maar bij de volgende loop kan die waarde alweer anders zijn en buiten de "doe niks" waarde vallen.
Hierdoor gaat het paneel staan pendelen wat onnodig is voor het stellen van een zonnepaneel.
Het pendelen is ook niet goed voor de motoren en het verbruikt stroom en dat is het laatste wat je wilt.

Ik heb op internet gezocht in hoeverre een zonnepaneel mag afwijken van de 90 graden instraling wil je zo min mogelijk verlies hebben en dat is 30 a 40 graden rondom de 90 graden, dus zowel links / rechts als op en neer.
Gister tussen gekeken met een graden boog hoeveel dat is en ik kom op ~2 uur eer het paneel in een nieuwe stand gezet zou moeten moet worden.
Mijn DELAY is 30 seconden......en dan wordt er alweer een nieuwe meting gedaan die de motoren gaat / kan aansturen.

Is een lange DELAY van bv 2 uur geen tijdelijk oplossing voor de buurvrouw zodat ik ook tijd heb om de nieuwe sketch te schrijven ?
Ik haal de potmeterwaarde uit de sketch en zet daar een vaste waarde van bv 2 uur op de plaats....idee ?

PS, de buurvrouw ligt graag in de tuin en zo gauw als er een zonnestraaltje in de tuin komt zit / ligt ze in de tuin.
Zelf hoor ik het niet omdat ik deels (70%) doof ben, maar zij hoort het wel als de motortjes gaan draaien.

[Gij Kieken Profiel]

In de hysteresis bepaal je of het dag of nacht is.
Dus je hebt die zogeheten vlag <myDayState> waarvan je de drempelwaardes eerder hebt ingesteld
naar jouw believen
const int dag_drempel = 700; //Kantelpunt voor DAG modus,bepaal zelf de waarde
const int nacht_drempel = 300; //Kantelpunt voor NACHT modus,bepaal zelf de waarde
Voor de schemerWaarde had ik gekozen voor dh, maar je kunt zowel avt gebruiken
of het gemiddelde van alles top,bottom,left,right maar denk je het jezelf aleen maar moeilijker
maakt zo (Het immers om een manier om iets tye laten werken)
Jij kiest dewelke jouw het best past.

Code: Alles selecteren

    if (myDayState == NACHT) { //Is het Nacht?
 // doe je code, zoals motors laten draaien etc...
   
 

 // if ((avr < dag_drempel) && (avl < dag_drempel))  // schemerwaarde
 // ik zou er maar een pakken want de andere is dan ook in die buurt
 //{


    digitalWrite(PinMotorLinks, LOW);
    digitalWrite(PinMotorRechts, HIGH);
    Serial.println("AZIMUTH   MOTOR NIGHT");
    lcd.setCursor(0, 1);
    lcd.print("AZIMUTH   :  NIGHT"); // print lcd row 2
  }


[Gij Kieken Profiel]

Uit je vorige posts heb ik begrepen dat je nog een aparte controller op de bureau hebt liggen.
Heb je al eens geprobeerd om die laatste hysteresis sketch te laden en wat te oefenen, proberen.
Ipv alles tegelijk 1 iets met een keer proberen en eens waarden veranderen om ea op te volgen in de Serial monitor.
Aja , nog een vraagje, der hangen toch eindeloop schakelaars op de motoren hé?

[Gompy Profiel Privébericht]

Ik ga de hele sketch opnieuw schrijven want ik plak telkens een pleister.

Voorlopig heb ik de sketch even met een LongDelay aangepast.

Code: Alles selecteren

#define SECOND 1000UL
#define MINUTE (SECOND * 60UL)
#define HOUR (MINUTE * 60UL)


en bij de delay in de loop

Code: Alles selecteren

delay(next_loop * MINUTE)


Hierdoor is (voorlopig) de activering van de loop tot 30 minuten in te stellen en desnoods tot 30 uur
Nu maar even afwachten of dit beter gaat en dan zou het paneel eventueel weer wat moeten gaan doen.
Mmmmm.....30 minuten voorbij en hij doet (nog) niets

Ik heb de test opstelling hier liggen om eea eerst te proberen en dan pas in de werkelijke sketch toe te passen.
In het begin deed ik het op het paneel zelf, maar als het slecht weer was / werd zat ik buiten in de regen en kou en zoveel heb ik voor mijn hobby nou ook weer niet over.
Ik heb een actieve USB-kabel van 15 meter gekocht en die aan het paneel gemaakt en nu kan ik binnen zitten en switchen tussen de set binnen en buiten zonder daadwerkelijk met de laptop naar buiten te hoeven

De hysteresis daar ben ik mee bezig, maar ik wil eigenlijk op een zo kort mogelijke termijn mijn buurvrouw tevreden stellen anders krijgen we echt ruzie.

De motoren zijn uitgevoerd met eindschakelaars die de aansturing van de plus onderbreken, ergens in dit draadje staat wel hoe ik het gedaan heb.
Er worden geen signalen naar de Arduino gebruikt om de motoren een andere richting op te sturen.

[Gij Kieken Profiel]

Verderop in de sketch zal je moeten testen of het dag is en dan de nodige motoren laten lopen(regelen).

[Gompy Profiel Privébericht]

De motortjes (kunnen) draaien met de snelle oplossing totdat de sensoren binnen de tolerantie vallen (+/- 5 a 10 seconden) en stoppen dan voor 30 minuten.
Ik denk dat de buurvrouw daarmee voorlopig wel kan leven (de winter komt er toch aan) en ik kan nu mijn energie in de nieuwe sketch gaan steken.

Eerst maar eens een flowschema maken wat ik het paneel nu echt wil laten doen, de eerste keer was het gewoon aankl*ten tot het werkte.
Wat niet wil zeggen dat het voor niets is geweest, ik heb een hoop geleerd (oa van Koepel) met dat aankl*ten.