Vraag Servo's

Hallo Allen,

Ik ben nu ongeveer een week of 2 bezig met Arduino en begin het aardig te begrijpen.
Ik zal even kort beschrijven wat mijn projectje inhoud.

Er word gebruik gemaakt van 3 led ringen van 24 leds en van 3 servo’s ik maak hierbij gebruik van die goedkope blauwe SG90 servos welke allen zijn aangesloten op mijn arduino uno bordje.

Op dit moment heb ik alle plus draden van zowel de servos als van de led ringen op de 5v output van het arduino bordje via zo een breadboard.

De bedoeling is dat ledring 1 geactiveerd word en te samen met het verhogen van de helderheid van die leds ook servo 1 beweegt naar een bepaalde positie.
dan een wacht van x sec

Bovenstaande ook voor ledring 2 en 3.

Nu heb ik het zo ver dat dit werkt. Echter random verspringen de servos gewoon, ze krijgen dan een pulse ergens vandaan, tenminste zo lijkt het.

Nu las ik dat het kan komen doordat ik de servos rechtstreeks van arduino voorzie van power. Nu heb ik gisteren de plussen en de minnen van de servo aan een voeding gekoppeld en de pulse draad aan de arduino. ik hield het zelfde probleem.

hierbij de code:

#include <Adafruit_NeoPixel.h>
#include <Servo.h>


// Hier vul je in hoeveel leds jou led ring heeft
#define NUMPIXELS1 24
#define NUMPIXELS2 24
#define NUMPIXELS3 24

Servo myservo1;
Servo myservo2;
Servo myservo3;

// Hier niets aan veranderen. Dit zijn een variable die gebruikt word om later waardes bij op te tellen om de leds te dimmen.
int Brightness1 = 0;
int Brightness2 = 0;
int Brightness3 = 0;
int Servo1travel= 0;
int Servo2travel= 0;
int Servo3travel= 0;

//Hier geef je de maximale helderheid in van de led ringen.
int Helderheid1 = 30;
int Helderheid2 = 30;
int Helderheid3 = 30;

int servo1min = 0;
int servo2min = 0;
int servo3min = 0;
int servo1max = 180;
int servo2max = 180;
int servo3max = 180;

// Hier geef je de tijd in tussen de stappen van het dimmen.
int dimdelay = 50;
int servodelay = 50;

// Hier worden de pixelringen geinitialiseerd

Adafruit_NeoPixel pixels1 = Adafruit_NeoPixel(NUMPIXELS1, 5, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixels2 = Adafruit_NeoPixel(NUMPIXELS2, 6, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixels3 = Adafruit_NeoPixel(NUMPIXELS3, 7, NEO_GRB + NEO_KHZ800);

int delayval = 0; // vertraging tussen het aanzetten van de idividuele leds
int Bloemdelay = 3000; //delay tussen de verschillende ringen
int Runonce = 0;

//int lightSensorPin = A0;
//int analogValue = (0);
//int Brightness = 0;


void setup()  {
  pixels1.begin();
  pixels2.begin();
  pixels3.begin();
  pixels1.setBrightness(1);
  pixels2.setBrightness(1);
  pixels3.setBrightness(1);
  myservo1.attach (9);
  myservo2.attach (10);
  myservo3.attach (11);
  myservo1.write (servo1min);
  myservo2.write (servo2min);
  myservo3.write (servo3min);  
  Serial.begin(9600);
}

void loop()

{           
    ring1();
    delay (Bloemdelay);
    ring2();
    delay (Bloemdelay);      
    ring3();
  
}




 
void ring1() {
  for(int i=0;i<NUMPIXELS1;i++){

    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
    pixels1.setPixelColor(i, pixels1.Color(255,255,255)); // Witte kleur    
    pixels1.show(); // Dit zend de pixel kleur naar de hardware.   
    delay(delayval); // Wachttijd (in milliseconden).
    
    }

    while (Brightness1<=Helderheid1){      
      Brightness1++;
      pixels1.setBrightness(Brightness1);
      pixels1.show();
      

    Servo1travel++;
    Serial.print (Servo1travel);
    myservo1.write(Servo1travel);
    delay (servodelay);
}
}
  
void ring2() {
  for(int i=0;i<NUMPIXELS2;i++){
    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
    pixels2.setPixelColor(i, pixels2.Color(255,255,255)); // Moderately bright green color.
    pixels2.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
          }
    
while (Brightness2<=Helderheid2){      
      Brightness2++;
      pixels2.setBrightness(Brightness2);
      pixels2.show();
      delay (dimdelay); 
 
   Servo2travel++;
   Serial.print (Servo2travel);
   myservo2.write(Servo2travel);
   delay (servodelay);
     }
  }

void ring3() { 
  for(int i=0;i<NUMPIXELS3;i++){

    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
    pixels3.setPixelColor(i, pixels3.Color(255,255,255)); // Moderately bright green color.
    pixels3.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
    
        }
                
    while (Brightness3<=Helderheid3){      
      Brightness3++;
      pixels3.setBrightness(Brightness3);
      pixels3.show();
      delay (dimdelay); 
      
   Servo3travel++;
   Serial.print (Servo3travel);
   myservo3.write(Servo3travel);
   delay (servodelay);
     }

  }

Heeft iemand ideeen?
alvast heel erg bedankt.

Hoi denniscamos, welkom.

Servos zijn grote stroomverbuikers.
Om te testen zou je 1 servotje zonder mechanische belasting kunnen aansluiten op de 5 volt van de Arduino.
Maar die 5 volt is daar niet voor bedoeld en zal ook al zonder mechanische belasting, elektrisch overbelast worden.
Daarom kun je jezelf het beste aanleren die dingen gewoon via een aparte voeding te voeden.

LED ringen zijn ook aardige stroomverbruikers, want jouw LED ringen met 24 WS281x lampjes er op, maken dus in totaal 72 LEDs.
En wanneer je die in jouw lichtgroene (volgens de beschrijving in je code) kleur met 255,255,255 (in werkelijkheid fel wit dus) aanstuurt, dan verbruiken ze dus ook 72 keer de maximale stroom die ze krijgen kunnen.
Dus daar geldt hetzelfde voor: een andere, voldoende krachtige voeding die niet van je Arduino board af komt.

Als je onderaan mijn posts kijkt (alle posts, niet alleen deze), dan zie je een opmerking staan over grounds.
Die staat daar omdat dat 1 van de meest voorkomende vergissingen is.
Wanneer je iets met de Arduino wil verbinden, kun je dat niet met slechts 1 draadje doen.
Ook niet als die verbinding een 1 draads-verbinding genoemd word.
Want jouw stuursignalen kunnen alleen betrouwbaar verwerkt worden, als ze ergens mee vergeleken kunnen worden.
Dat gemeenschappelijke (common) punt is over het algemeen GND.
En daarom moet je de GNDs van alle voedingen, Arduino en modules aan elkaar knopen.
Alleen wanneer (bijvoorbeeld om veiligheidsredenen zoals koppeling met een gevaarlijke (230 VAC) spanning) een scheiding noodzakelijk is, dan moet je die GNDs niet koppelen.
Maar aan het onderdeel dat die scheiding dan realiseert, zul je een ingaande GND en een uitgaande GND hebben(die dan een andere naam en /of symbool heeft, zoals GND1).
In jouw geval zou ik een voeding nemen die 1A per servo uit kan sturen, en 2A per ring.
Dat is dus 9 Ampère, en das een stevige voeding.

Voor jou om het na te rekenen, een enkele LED waarvan er 3 in 1 pixel zitten, word geacht maximaal 0.02 Ampère te trekken.
Das niet zo veel en valt wel mee.
Als je de pixel wit laat oplichten, word t al wat meer, 0.06 Ampère.
Doe dat dan eens 24 keer.
Dan krijg je ineens een totaal van maar liefst 1.44 Ampère voor 1 ring.
En dan gaat t nogal hard met die stromen, toch iets om even rekening mee te houden.

Dus:
Dikke voeding, en in dit geval alle GNDs aan elkaar.

Zorg er ook voor dat de draden naar je verbruikers (servos en ringen) de stroom ook aan kunnen.
En ga niet proberen zulke stromen door een breadboardje te sturen want die is daar niet voor gemaakt en kan dat niet aan.

Wow, wat een fijn en helder antwoord.
Ik ga eens even kijken of ik zo een voeding heb liggen. ik had echt geen idee dat het om zo veel amps ging.
Het is natuurlijk ook maar 5 volt dus dan gaat het wat sneller.

Aangezien ik de leds niet maximaal laat branden maar op bijvoorbeeld maar 20 procent denk ik dat het met die amperages wel mee valt.

Ik ga het eerst proberen met een 3 amp voeding en ga kijken of het effect heeft.
Als het inderdaad effect heeft ga ik op zoek naar een andere voeding.

Verder zag ik ook dat er gebruik gemaakt word van weerstanden tussen de control pin en de ledring. Dit heb ik er nu niet tussen zitten.
Is dit erg belangrijk? **
** Ah ik heb het al gevonden. het is niet nodig volgens de fabrikant. 24 Bits 24 X WS2812 5050 RGB LED Ring Lamp Light with Integrated Drivers
Constant Current Drive: Each one has 18mA constant current drive so the color will be very consistent even if the voltage varies, and no external choke resistors are required making the design slim.

Ik houd je op de hoogte!

Groet,
Dennis

Hoi.

De weerstand tussen Arduino data pin en WS LED strip/ring/constructie is wel nodig.
De weerstand waar de fabrikant over schrijft, heeft een andere functie en zou dan ook ergens anders in het circuit geplaatst moeten worden.
Maar vanwege de constructie van de WS LEDs, is dat niet mogelijk en is er daarom voor een andere passende oplossing gekozen.

De weerstand tussen Arduino pin en LED strip, beveiligt zowel de Arduino als de strip in geval de andere kant een of ander defect zou hebben.
Dat beveiligen gebeurt door de stroom te beperken tot veilige niveaus zodat in geval van zulke fouten, er niets opgeblazen zal worden.
Over t algemeen word een waarde tussen de 220 Ohm en 560 Ohm aangehouden hiervoor.
470 Ohm is dan een waarde die het gemakkelijkst te vinden zal zijn en die een doorgewinterde elektronica hobbyist altijd in huis zou moeten hebben.

Alle hier genoemde Ohmse waarden, zijn standaard e96 reeks waarden die het meest voorkomen.

Pfiew…

Ik word een tikkie droevig…
Ben nu ongeveer 3 uur bezig en ik dacht laat ik het even super simpel doen.
Enkel twee servo’s aangesloten op een 5v voeding 3 amp via het breadboard.
Servos hebben geen load.

De minnen van de servos verbonden met de min van arduino en de min van de voeding.
Plus van de voeding verbonden met de plussen van de Servos.

Als ik de code upload en het programma begint dan schokken die servos gewoon. Eerst was het ook nadat de de variabelen false waren dat heb ik gelukkig niet meer.

Ik stel deze vraag maar omdat als het bordje niet goed zou zijn ik hier weken mee bezig zou kunnen zijn en terwijl het niet aan mijn dommigheid ligt.

hier is de code:

#include <Adafruit_NeoPixel.h>
#include <Servo.h>


// Hier vul je in hoeveel leds jou led ring heeft
#define NUMPIXELS1 24
#define NUMPIXELS2 24
#define NUMPIXELS3 24

Servo myservo1;
Servo myservo2;
Servo myservo3;

// Hier niets aan veranderen. Dit zijn een variable die gebruikt word om later waardes bij op te tellen om de leds te dimmen.
int Brightness1 = 0;
int Brightness2 = 0;
int Brightness3 = 0;
int Servo1travel= 0;
int Servo2travel= 0;
int Servo3travel= 0;
int Pixelcounter1 = 0;
int Pixelcounter2 = 0;
int Pixelcounter3 = 0;

//Hier geef je de maximale helderheid in van de led ringen.
int Helderheid1 = 20;
int Helderheid2 = 30;
int Helderheid3 = 30;

int servo1min = 20;
int servo2min = 20;
int servo3min = 20;
int servo1max = 140;
int servo2max = 140;
int servo3max = 180;

// Hier geef je de tijd in tussen de stappen van het dimmen.
int dimdelay = 50;
int servodelay = 100;

// Hier worden de pixelringen geinitialiseerd

Adafruit_NeoPixel pixels1 = Adafruit_NeoPixel(NUMPIXELS1, 5, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixels2 = Adafruit_NeoPixel(NUMPIXELS2, 6, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixels3 = Adafruit_NeoPixel(NUMPIXELS3, 7, NEO_GRB + NEO_KHZ800);

int delayval = 0; // vertraging tussen het aanzetten van de idividuele leds
int Bloemdelay = 3000; //delay tussen de verschillende ringen
int Runonce = 0;

void setup()  {
  Serial.begin(9600);
  pixels1.begin();
  pixels2.begin();
  pixels3.begin();
  pixels1.setBrightness(1);
  pixels2.setBrightness(1);
  pixels3.setBrightness(1);
  myservo1.attach (9);
  myservo2.attach (11);
  myservo3.attach (10);
  myservo1.write (servo3min);
  myservo2.write (servo3min); 
  myservo3.write (servo3min);
 }

void loop()
{
ring1();
ring2();
}




 
void ring1() {
  while (Pixelcounter1<=NUMPIXELS1){
    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
    
    pixels1.setPixelColor(Pixelcounter1, pixels1.Color(255,255,255)); // Witte kleur
    Pixelcounter1++;
    pixels1.show(); // Dit zend de pixel kleur naar de hardware.
    delay(delayval); // Wachttijd (in milliseconden).
       }
    
    while (Brightness1<=Helderheid1){
      Brightness1++;
      pixels1.setBrightness(Brightness1);
      pixels1.show();
      Servo1travel++;
      myservo1.write(Servo1travel);
      delay (25);
    }
      while (Servo1travel<=servo1max){
      Servo1travel++;
      myservo1.write(Servo1travel);
      delay (25);
    }
}

void ring2() {
  while (Pixelcounter2<=NUMPIXELS2){
    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
    
    pixels2.setPixelColor(Pixelcounter2, pixels2.Color(255,255,255)); // Witte kleur
    Pixelcounter2++;   
    pixels2.show(); // Dit zend de pixel kleur naar de hardware.   
    delay(delayval); // Wachttijd (in milliseconden).   
    }
    
    while (Brightness2<=Helderheid2){     
      Brightness2++;
      pixels2.setBrightness(Brightness2);
      pixels2.show();      
      Servo2travel++;
      myservo2.write(Servo2travel);
      delay (25);
    }
    while (Servo2travel<=servo2max){
      Servo2travel++;
      myservo2.write(Servo2travel);
      delay (25);
    }
}

Laat maar ik ben er al uit....

Echt zo dom....

iets mis in de counter van de servo steps...

Dit is geen dommigheid.
Het is een leerproces.
Je hebt uiteindelijk zelf gevonden wat er fout ging; heel mooi.
Dat ga je niet snel weer vergeten.

Hi,

ik heb toch een probleepje.
Op de een of andere manier kwam ik niet helemaal van het schokken van de servo’s af.
Nu heb ik het onderzocht en lijkt het op te treden als de delay groter word dan 25ms.
Dus stel ik zet Dimservodelay op 30 dan krijg ik schokjes midden in de gang naar de max servo uitslag.

zet ik hem op 25 dan werkt het prima.

Iemand een idee? Of kan iemand het reproduceren het is enkel een servo op pin 3 drukken.

#include <Adafruit_NeoPixel.h>
#include <Servo.h>


// Hier vul je in hoeveel leds jou led ring heeft
#define NUMPIXELS1 24
#define NUMPIXELS2 24
#define NUMPIXELS3 24

Servo myservo1;
Servo myservo2;
Servo myservo3;

// Hier niets aan veranderen. Dit zijn een variable die gebruikt word om later waardes bij op te tellen om de leds te dimmen.
int Brightness1 = 0;
int Brightness2 = 0;
int Brightness3 = 0;
int Posservo1= 0;
int Posservo2= 0;
int Posservo3= 0;
int Pixelcounter1 = 0;
int Pixelcounter2 = 0;
int Pixelcounter3 = 0;

//Hier geef je de maximale helderheid in van de led ringen.
int Helderheid1 = 30;
int Helderheid2 = 30;
int Helderheid3 = 30;

int servo1min = 0;
int servo2min = 0;
int servo3min = 0;
int servo1max = 140;
int servo2max = 140;
int servo3max = 180;

// Hier geef je de tijd in tussen de stappen van het dimmen.
int dimdelay = 50;
int Dimservodelay = 25;

// Hier worden de pixelringen geinitialiseerd

Adafruit_NeoPixel pixels1 = Adafruit_NeoPixel(NUMPIXELS1, 5, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixels2 = Adafruit_NeoPixel(NUMPIXELS2, 6, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixels3 = Adafruit_NeoPixel(NUMPIXELS3, 7, NEO_GRB + NEO_KHZ800);

int delayval = 0; // vertraging tussen het aanzetten van de idividuele leds
int Bloemdelay = 3000; //delay tussen de verschillende ringen
int Runonce = 0;

void setup()  {
  Serial.begin(9600);
  pixels1.begin();
  pixels2.begin();
  pixels3.begin();
  pixels1.setBrightness(1);
  pixels2.setBrightness(1);
  pixels3.setBrightness(1);
  myservo1.attach (3);
  myservo1.write (servo1min);
 }
void loop()
{
ring1();
}

void ring1() {
  while (Pixelcounter1<=NUMPIXELS1){
    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
   
    pixels1.setPixelColor(Pixelcounter1, pixels1.Color(255,255,255)); // Witte kleur
    Pixelcounter1++;
    pixels1.show(); // Dit zend de pixel kleur naar de hardware.
    delay(delayval); // Wachttijd (in milliseconden).
       }   
    while (Brightness1<Helderheid1){
      Brightness1++;
      pixels1.setBrightness(Brightness1);
      pixels1.show();
      Posservo1++;      
      myservo1.write(Posservo1);
      delay (Dimservodelay);
      Serial.println (Posservo1);
     
    }
      while (Posservo1<=servo1max){
      Posservo1++;
      myservo1.write(Posservo1);
      delay (Dimservodelay);
      Serial.println (Posservo1);
          }
}

Groet,
Dennis

Kun je beschrijven wat jij ziet als je het over een schokkende servo hebt ?

Met jouw code ga je telkens een stapje van 1 graad zetten, en wacht vervolgens heel kort voor het volgende stapje gezet word.
Op die wijze beperk je de draaisnelheid van de servo.
Een servo probeert zo snel mogelijk de opgegeven nieuwe waarde te behalen.
Maar daarbij wordt ie natuurlijk wel beperkt door een aantal zaken, dus er zijn wel grenzen aan de snelheid die haalbaar is.

Maak voor de gein eens bijvoorbeeld een satéprikker aan de arm van je servo vast, of iets anders van lengte waardoor de de beweging veel duidelijker te volgen word.
Laat dan de servo met jouw code bewegen, en een keer met een standaard code van 90 naar 150 en dan naar 30 graden bijvoorbeeld.
Tussen elke stap 90 - 150 een pauze van een seconde of 5 of zo, zodat je goed kunt volgen wat daar gebeurt.

Ik vermoed dat je gaat zien dat bij jouw stukje code stapjes gezet worden, en bij de ander code dat de servo er een stuk sneller heen draait, maar ook dat ie als ie bijna bij de gewenste waarde is, langzamer gaat draaien (heel goed opletten dus wat je ziet).
Door dit zo te doen, is de servo snel in de buurt van de eindwaarde, maar kan ie best nauwkeurig op die eindwaarde uitkomen zonder er overheen te schieten of te vroeg te stoppen.
Maar ik weet natuurlijk niet 100% zeker of die servo's dat ook werkelijk zo doen.

Door een servo die op die wijze werkt telkens met 1 graad verschil aan te sturen, laat je de servo ook altijd op de laagst mogelijke snelheid draaien.
Maar wacht je te lang, dan zal de servo dus telkens even tot stilstand komen.

Het kan best gecompliceerd worden nu, maar om iets in beweging te krijgen, is een grotere kracht nodig dan om iets wat al in beweging is, door te laten bewegen.
Daarom kan het zijn dat de servo te snel start en dan ook snel weer moet stoppen, of er zelfs toch al overheen zal schieten en dan terug zou moeten draaien (en wanneer dat eenmaal gestart is, zal het probleem ook niet meer te stoppen zijn, want dit geldt dan bij linksom of rechtsom draaien, naar ook bij het rechtsom of linksom terug draaien om dat weer te corrigeren).

Dat heeft niet alleen met de servo zelf te maken, maar ook met de belasting van die servo in je project.
Dus het kan zijn dat wanneer je een losse servo iets perfect kunt laten doen, het in jouw opgebouwde project ineens anders is.
Mogelijk zijn er duurdere servo's te vinden die dit niet of minder hebben.
Maar houd er ook rekening mee dat wat je voor ogen had, wellicht beter niet met een servo te maken is.

Als je bovenstaande 2 keer goed doorleest, zou je kunnen concluderen dat er meer dan 1 ongewenste gedragingen te bedenken zijn die men als schokkende beweging zou kunnen typeren.
Daarom vroeg ik dus aan het begin wat je precies ziet gebeuren en gaf ik een mogelijkheid om beter te kunnen zien wat er dan precies gebeurt.

Verder zie ik in jouw code, met name in de functie ring1() dat je eerst de LED ring en de servo aanstuurt, en vervolgens ook doorgaat met de servo aansturen wanneer diens eindwaarde nog niet bereikt zou zijn.

Ik vraag me nu af of je in het 1e stukje nu niet gaat vergeten om bij te houden waar de servo inmiddels is, en of dat wel binnen de eindwaarde zal blijven.
Ik zie ook tot nog toe maar 1 stuurrichting voorkomen (de waarde word alleen maar opgehoogd, niet verlaagd).

Verder zie ik dat je de blokkerende code while... gebruikt.
Dat zal nu nog geen probleem zijn, maar wanneer je straks de 3 ringen tegelijk (nou ja, voor zover een mens dat kan volgen) en onafhankelijk van elkaar wil aansturen, zal dat niet meer gaan werken.
Maar laten we eerst het schokkende gedrag maar aanpakken.

Goedemiddag,

Allereerst weer heel erg bedankt voor het antwoord.
Om het een beetje makkelijker te maken heb ik een filmpje gemaakt van het schokkende servo probleem.

Schokkende servo

Ik maak gebruik van onderstaande code.
Deze veranderd nog al eens aangezien ik maar bleef proberen…

#include <Adafruit_NeoPixel.h>
#include <Servo.h>


// Hier vul je in hoeveel leds jou led ring heeft
#define NUMPIXELS1 24
#define NUMPIXELS2 24
#define NUMPIXELS3 24
int ldr = 0;  //analog pin to which LDR is connected
int ldr_value = 0; //variable to store LDR values

Servo myservo1;
Servo myservo2;
Servo myservo3;

// Hier niets aan veranderen. Dit zijn een variable die gebruikt word om later waardes bij op te tellen om de leds te dimmen.
int Brightness1 = 0;
int Brightness2 = 0;
int Brightness3 = 0;
int Posservo1= 0;
int Posservo2= 0;
int Posservo3= 0;
int Pixelcounter1 = 0;
int Pixelcounter2 = 0;
int Pixelcounter3 = 0;

//Hier geef je de maximale helderheid in van de led ringen.
int Helderheid1 = 30;
int Helderheid2 = 30;
int Helderheid3 = 30;

int servo1min = 90;
int servo2min = 0;
int servo3min = 0;
int servo1max = 0;
int servo2max = 140;
int servo3max = 180;

// Hier geef je de tijd in tussen de stappen van het dimmen.
int dimdelay = 50;
int Dimservodelay = 50;

// Hier worden de pixelringen geinitialiseerd

Adafruit_NeoPixel pixels1 = Adafruit_NeoPixel(NUMPIXELS1, 5, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixels2 = Adafruit_NeoPixel(NUMPIXELS2, 6, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixels3 = Adafruit_NeoPixel(NUMPIXELS3, 7, NEO_GRB + NEO_KHZ800);

int delayval = 0; // vertraging tussen het aanzetten van de idividuele leds
int Bloemdelay = 3000; //delay tussen de verschillende ringen
int Runonce = 0;

void setup()  {
  Serial.begin(9600);
  pixels1.begin();
  pixels2.begin();
  pixels3.begin();
  pixels1.setBrightness(0);
  pixels2.setBrightness(1);
  pixels3.setBrightness(1);
  myservo1.attach (3);
  myservo1.write (servo1min);
 }
 
void loop()
{
ldr_value = analogRead(ldr);
if (ldr_value > 200){
ring1open();
}
else if (ldr_value <200) {
ring1dicht(); 
}
}


void ring1open() {
   
pixels1.setBrightness(1);

     while (Pixelcounter1<=NUMPIXELS1){
    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
   
    pixels1.setPixelColor(Pixelcounter1, pixels1.Color(255,255,255)); // Witte kleur
    Pixelcounter1++;
    pixels1.show(); // Dit zend de pixel kleur naar de hardware.
    delay(delayval); // Wachttijd (in milliseconden).
       }          
    while (Brightness1<Helderheid1){
      Brightness1++;
      pixels1.setBrightness(Brightness1);
      pixels1.show();
      Posservo1+=2;   
      myservo1.write(Posservo1);
      delay (Dimservodelay);     
    }
      while (Posservo1<servo1max){
      Posservo1+=2;
      myservo1.write(Posservo1);
      delay (Dimservodelay);
          }
}


void ring1dicht() {          
    while (Brightness1>0){
      Brightness1--;
      pixels1.setBrightness(Brightness1);
      pixels1.show();
      Posservo1-=2;     
      myservo1.write(Posservo1);
      delay (Dimservodelay);
    }
      while (Posservo1>servo1min){
      Posservo1-=2;
      myservo1.write(Posservo1);
      delay (Dimservodelay);
          }
}

Ik ben echt heel erg benieuwd of je er iets aan kan zien.

Met vriendelijke groet,
Dennis Camps

Hoi.

Nou, dat is inderdaad wel wat je schokken mag noemen.
Dit is totaal niet wat ik had verwacht en echt niet goed.
Zijn de bewegingen die je maakt, gedaan met de code uit je bericht hierboven ? (het lijkt er wel op)

Aangezien je al met modelbouw bekend bent, heb je ook een afstandbediening en ontvanger over die je kunt proberen ?
Dan zou je dus de servo en eventueel de ontvanger moeten voeden uit de voeding die je in je filmpje ook gebruikt, of de servo uit die voeding voeden, de GND met de ontvanger's GND verbinden, en het signaal uit de ontvanger aan de signaal draad van de servo moeten knopen.
Heb je dan ook zulk gedrag ?
Want dan ligt het aan de servo of aan de voeding.
En je had al andere servo's gebruikt vertelde je.
En als je m daarna (of er voor want gemakkelijker te doen) test met de standaard voeding / accu van je ontvanger ?

Welke Arduino variant gebruik je eigenlijk ?
Had je ook al andere pinnen uit je Arduino geprobeerd dan pin 3 ?

1: Het lijkt wel alsof de servo telkens in één klap terug wil naar zijn beginpositie; de schok is nl. veel sterker dan bij een stapje van één graad. Maar in de code zie ik niets wat daarop wijst. Zou je eens een filmpje willen maken waar Dimservodelay een flink grotere waarde heeft, bv. 200? Misschien is daar iets meer uit af te leiden.

2: Begrijp ik goed dat de servo één graad draait na een "Posservo1+=2;" ?

3: Doe eens "Serial.println(Posservo1);" na elke "myservo1.write(Posservo1);" ? NB.: Dat zijn er vier en ik begrijp eigenlijk niet waarom je dat zo gedaan hebt.

4: Wat ik vreemd vind is dat "int servo1min = 90;" en "int servo1max = 0;". Dat zou ik andersom verwachten, en voor servo2 en servo3 is dat ook idd. zo. Misschien wel juist de bedoeling, maar ik doorzie het niet.

5: Is de code die je postte helemaal compleet? Of draait er nog meer, waarbij een timer of een interrupt iets ongewensts doet met pin 3?

Goedemorgen,

@Mas3
Het is met exact de code zoals ik poste gemaakt. ik gebruik nu een 3 amp voeding op 5 v. Dit zou echt goed moeten zijn. sterker nog ik denk dat zo een mini servo zelfs zou moeten werken rechtstreeks van het arduino bordje zonder load.

Ik heb ook andere pinnen gebruikt. Sterker nog ik denk dat ik ze allemaal al heb geprobeerd. Ik heb nog niet geprobeerd om de servo aan een bec te koppelen zoals je eigenlijk zegt maar dan zonder de ontvanger. Maar ik kan me echt niet voorstellen dat het een evrschil zou maken.

Ik maak gebruik van een Arduino uno bordje van Velleman.

@ Erik_Baas

1 Als ik de delay groter maak bijvoorbeeld 75 dan lijkt het meer op te treden, maar ook hier zie ik niet echt logica in.

2 Die plus van 2 heb ik zo gedaan omdat het leek dat het schokken dan iets minder werd. Uit eindelijk zou het de bedoeling zijn om elke posservo1 te laten plussen met 1.

3 Ik heb Serialprint lnl gedaan en je ziet echt dat ie mooi op loopt. Ik heb gekeken of de posservo1 in derial monitor veranderde op het moment van de schok maar dat is niet zo.

4 Ik heb dat gedaan om de gang even te beperken :slight_smile: ik had een vleugel gepakt van een vliegtuig en wou niet dat de rolroeren afbraken. dus die waarde is niet echt belangrijk. het gaat echt puur om het schokken.

5 de code is compleet.

Toen ik nog niet wist dat je niet alles kon poweren over de arduino heb ik alles aangekoppeld gehad.
Dus 3 ledringen en 3 servos. Zou het kunnen dat het bordje gewoon stuk is?

Groet,
Dennis

Nogmaals, je hebt een probleem met de timers, zet je neopixel eens uit en draai alleen de servo. Het kan ook goed zijn dat je sensor allerlei waarden oppakt tussendoor en die direct doorgeeft aan de servo.
en je doet iets raars met die while, als de waarde < dan doe je -2, prima. maar eronder staat een while die kijkt naar de servo positie en verhoogt die dan met 2+. Zorg dat je maar 1 servo instructie in je hele programma hebt. dus je rekent alles eerst uit, en dan ga je even nar een functie toe om de servo te zetten.
zo ook hetzelfde voor je ledringen.

Hi,

Ik heb even gekeken naar wat je bedoeld met min1 en dan weer plus 2.
Ik zie dat niet. Niet anders dat ik bij licht open ga en bij donker dicht. Dat ik een waarde kan zetten en hem daar dan in een keer naar toe kan laten gaan dat kan zonder problemen.
Maar het moet moet toch mogelijk zijn om dit vertraagt te doen.
En als de timers het zouden zijn dat deed hij het toch iedere keer en dan zou het in de serial monitor ook te zien moeten zijn.

Groet,
Dennis

Er is een bekend probleem als je de NeoPixel-library en de Servo-library tegelijkertijd gebruikt, zie https://learn.adafruit.com/neopixels-and-servos:

"The issue arises that servos also have very specific timing requirements of their own, and the Arduino Servo library uses interrupts to achieve this. So every time the NeoPixel library turns off interrupts, even for a moment, the servos will lose track of time (and therefore position) and shake unpredictably."

Dit zou heel goed het probleem kunnen zijn dat je ziet.

Het is wel mogelijk een servo library te maken die geen interrupts gebruikt, maar ik weet zo niet of die al bestaan. Op Arduinos met een SAMD21 gebruik ik mijn eigen PWM-library om servos aan te sturen, maar ik weet niet of dat voor jou gaat werken; bovendien zijn er voor die Arduinos Neopixel-libraries die servos wel met rust laten.

Hmmm, dat zou heel goed kunnen natuurlijk. Goed punt om eens uit te gaan zoeken…

Ik ga op onderzoek uit en zal mijn bevinding hier posten.
Groet Dennis,

Dit is dus de reden van mijn vragen in mijn vorige bericht.
Ik probeer in stapjes dichter bij de oorzaak te komen.
Maar als je dan stappen gaat overslaan omdat je eerder al iets wat daar op lijkt hebt geprobeerd, dan gaat deze aanpak niet werken.
Je kunt de huidige code aanpassen door alles wat met je LEDs te maken heeft als commentaar te zetten (// voor elke regel).
Dat is dus inclusief de library die je klaarzet bovenaan je code.

Vermoedelijk zul je dan het probleem in de servo's niet meer hebben, waarmee je deze oorzaak bevestigt.

Behalve een SAMD21 controller, met diens eigen nadelen, is er ook de mogelijkheid bij Adafruit te kijken naar een servo shield (klik !).
Dan heb je ook geen last meer van timer-hinder.
Even kijken wat voor jou de beste oplossing zal zijn.

Hi,

Ik heb even zitten lezen en ik denk dat zo een adafruit shield de beste optie gaat zijn.
Ik zal even kijken of ik ze in NL kan bestellen en laat jullie mijn bevindingen weten nadat ik het heb geprobeerd.

Bedankt voor de geboden hulp to nu toe.

Groet,
Dennis

Hi,

Voordat ik bestel kan iemand me vertellen wat het verschil is tussen een shield en of een driver?

Driver
Shield

groet,
Dennis