Zonnetracker vollop benut

[shooter Profiel Privébericht]

zo hier nog eentje die werkt.
https://create.arduino.cc/projecthub/DemetrisEng/solar-tracker-35w-with-dc-motors-1b5ac6?ref=platform&ref_id=424_trending___&offset=28

[Gompy Profiel Privébericht]

Nou ja werkt.......er zit totaal geen tolerantie in de sketch, dat ding vliegt gewoon van linkt naar rechte en op en neer.
Hang daar maar eens een paneel van 40 kg aan dan vliegen de stukken je om de oren.
Let vooral op de laatste 2 a 3 seconden.....dat wil ik toch echt niet met mijn paneel meemaken....en doet dat gelukkig ook niet.

[shooter Profiel Privébericht]

ach ik zag hem gewoon bij het zoeken naar totaal iets anders.

[Gij Kieken Profiel]

De Macgyver methode,je weet wel zo met een zwitsers mes en een rolletje DucTape.
Het is dan ook een manier van het veertiende knoopsgat.
Zo zal het paneel ieder haf uur 1minuut de tijd hebben om te rammelen.
Regelen druf ik het niet meer noemen.
Met jouw actieve Usb kabel kun je nu vanuit je luie stoel dit proberen.

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
 
// 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

//Nodig voor de asynchrone Timer
unsigned long currentMillis;    //De huidige tijd
unsigned long previousMillis;   //De vorige tijd
unsigned long interval = 60000; //Interval 1*1000mS*60S=1min
int enableState = HIGH;         //We starten met aan

void setup()
{
 Serial.begin(9600); // initialize the serial port
 
  lcd.init(); // initialize the lcd
  lcd.backlight(); // ON
 
}
 
void loop()
{

  //Hier de routine om de vlag enableState asynchroon te laten lopen
  currentMillis = millis();//Stel de tijd in
  if ( currentMillis - previousMillis >= interval) { //Is de tijd verlopen?
    previousMillis = currentMillis;//Onthoud de laatste waarde
    if ( enableState == HIGH) { //Was de State Aan ?
      interval = 1800000;//Nieuw interval Uit tijd op 30min (1*1000*60*30)
      enableState = LOW; //Zet de status Uit
    } else  {  //Was de State Uit?
      interval = 60000; //Nieuw interval Aan tijd op 1min
      enableState = HIGH; //Zet de status Aan
    }
  }


// 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
   
// 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;
// average difference of left and right LIGHT SENSORS 
  int dh = avl - avr;
   
//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();
 
  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(in3, HIGH && enableState);
  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 && enableState);
  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) && (avd < 700)) // sensor value
  {
  digitalWrite(in3, HIGH && enableState);
  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 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(in1, HIGH && enableState);
  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 && enableState);
  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))  // sensorvalue
  {
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH && enableState);
  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);//Deze regel speelt niet meer mee
  delay(300);//Dit in de plaats
 
  }
}
 
void print2digits(int number)
{
  if (number >= 0 && number < 10)
  {
    Serial.write('0');
  }
  Serial.print(number);
}


[Gompy Profiel Privébericht]

Je zou het paneel eigenlijk in werk moeten zien dan is het "probleem" waarschijnlijk ook begrijpelijker.
De DELAY werkt (.....) maar in de gehele sketch dus niet en dat is waarschijnlijk ook niet op te lossen met millis.

Ik zal proberen het uit te leggen wat ik zie als het probleem.....zeg maar een flowschema in woorden (alleen even voor UP / DOWN).

Paneel kijkt naar de waarde up, down, stop en night.
Doe up als dit nodig is anders doe down, stop of night.
DELAY 30 minuten.

Nu komt het, als bv het paneel de opdracht UP krijgt blijft het UP sturen totdat de DELAY om is.
In de volgende loop is het paneel door de langer tijd door gelopen en krijgt nu weer de opdracht DOWN.
Die opdracht DOWN duurt ook nu weer 30 minuten......idem met de volgende loop.

Eigenlijk moet de opdracht zolang duren totdat de STOP waarde is bereikt en DAN PAS moet de DELAY in gaan of naar de left / right opdracht gaan.

Hierdoor wordt het pendelen voorkomen omdat er tussen de nieuwe waarde sowieso een (instebare) hysteresis in de waarden zit (=tolerance).
Met wat ik boven heb geschreven zijn de waarden bereikt binnen de hysteresis en zal het paneel in de DELAY dus niets doen, het paneel staat gewoon te wachten op de volgende loop.
Maw, het moeten eigenlijk allemaal kleine loopjes woorden waarbij eerst de waarde bereikt moet worden voordat de volgende opdracht uitgevoerd mag worden.

[Gompy Profiel Privébericht]

Ik kom nog wat tegen op internet https://www.arduino.cc/reference/en/lan ... ture/else/ wat in mijn sketch waarschijnlijk niet goed staat (?)

Syntax
if (condition1) {
// do Thing A
}
else if (condition2) {
// do Thing B
}
else {
// do Thing C
}

In mijn sketch staat:

IF
ELSE
IF ELSE

Iemand die beter in de materie is die mij daar uitsluitsel over kan geven of dit wat uitmaakt ?

[Gij Kieken Profiel]

Probeer het eerst eens om te begrijpen.
Daarom net moet jouw Delay eruit .
Het houd alles tegen.(Blocking code)
Ik weet niet op hoeveel die nu staat?
Jij stuurt bv naar rechts en dan blokeert je code door delay, zoals je zegt blijft de motor gewoon doorlopen...
Door een timer te gebruiken blijft de void loop() lopen...en wordt er geregeld.
Probeer de andere voorbeeldjes ook nog eens misschien tot vervelens toe,vroeg of laat zal je €-cent wel vallen.

[Gompy Profiel Privébericht]

Totaal niet tot vervelens toe voor mij, waarschijnlijk eerder voor jullie, maar ik probeer het te begrijpen.
Ik waardeer het zelfs te zeerste dat er zoveel tijd in mij gestoken wordt.

Mijn "probleem" is dat ik het eerst wil begrijpen voordat ik iets doe anders heeft het voor mij geen nut.

Ik ga aan de slag met de timer zoals jij aangeeft als ik eerst zeker weet of de IF, ELSE, IF ELSE wel goed staat.
Nu begrijp ik dat bij een timer het programma gewoon blijft doorlopen, terwijl het bij een DELAY juist geheel stopt.

[Gij Kieken Profiel]

Een beetje ludiek uitgedrukt.
De code geeft de opdracht aan de motor Start met lopen.
De motor vraagt hoe ver?
Antwoord, weet het niet loop maar.
Vervolgens roep je Halt toe aan de code DELAY.
De motor loopt ondertussen verder want dit was ook gevraagd te doen.
Tot waar? hewel ,k'zal maar lopen tot de eindschakelaar.
Na de vertraging (delay) schiet de code terug wakker en meet de gemiddelde waarden.
Conclusie ,ahja ge staat veel te ver ,loop maar terug.
Net nadat je de opdracht gaf loop terug ,roep je terug Halt toe aan de code.
Dus de motor loopt terug ,naar waar,je kunt het al raden tot de andere eindeloop.
Enzo gaat dit maar door voor al je motoren.
Wat je mist bij deze is een feedback van de motor die zegt ik ben al zo ver ,wat moet ik doen?
Stoppen of doorgaan?
Met een stappenmotor geef je bv de opdracht loop 5° naat rechts( als ze niet blokeert of te veel wrijving ondervind
doet ze dat ook zonder stappen over te slaan°
Met een servo kan bv een encoder wieltje meelopen of een potmeter, die de stand van de motor weergeeft.
Dewelke oplossing je moet kiezen hangt een beetje af van het doel.(Vermogen ,koppel,etc...)
Met de draadstang nu kun je het wat inschatten door de spoed van je draadstang en de tijd de motor aan is.
Dus ipv opdracht loop maar ,zou je kunnen zeggen loop telkens 2 a 3 sec bv.

Koepel,Shooter,Niko (om er maar paar te noemen) en waarschijnlijk nog vele anderen hebben het al dikwijls vermeld.
Blink w/Delay probeer die te begrijpen.

[Gompy Profiel Privébericht]

Zo gaat het inderdaad !
Vandaar ook dat de loop eigenlijk constant door moet lopen totdat een / de situatie is bereikt dat de motor iets anders moet doen.
Tussen de nieuwe loop mag gerust 30 minuten zitten want per uur verloopt de zon maar 15 graden en de optimale instraling ligt op ongeveer 30 graden.
Dus één keer per 2 uur van positie veranderen is meer dan zat en op sommige dagen (geen zon) zal het paneel zelfs maar één keer per dag naar het licht hoeven draaien.
De DELAY zou niet nodig zijn geweest als bv een wolk roet in het eten zou gooien, waardoor twee sensoren iets meer licht krijgen dan de andere twee waarop weer een actie volgt.
Ik begin nu ook met je laatste code ook wat meer te snappen van een DELAY en een MILLIS, het is VEEEEEL overzichtelijker en voor mij begrijpbaar wat ik doe en waarom !

Vandaag zal het er niet van komen om de sketch aan te passen, maar ik ga er zsm mee aan de slag want hier heb ik vertrouwen in !!!!