helemaal nieuw hier, ik heb klein servo project

Projecten die niet passen in bovenstaande onderwerpen
Gebruikers-avatar
Berichten: 5
Geregistreerd: 17 Sep 2016, 20:31
Woonplaats: groesbeek

helemaal nieuw hier, ik heb klein servo project

Berichtdoor Henkie » 17 Sep 2016, 21:13

Beste mensen,

ik zal mij even voorstellen.

Mijn naam is Henk van Bergen
43 jaar
woonachtig in Groesbeek nabij Nijmegen.

van elektronica weet ik het nodige af, computer is ook geen probleem voor mij.

maar ik ben helemaal nieuwe in deze wereld.( dus heb geduld met mij ;) )

nu mijn project.

een van mijn hobby's is schieten ( & modelbouw).
nu doe ik bij ons op de schietclub alles wat betreft elektra, alarm beveiliging, camera beveiliging alles waar stroom doorheen loopt doe ik.

we hebben 2 banen 1 van 25 meter en een van 100 meter.
voor de 100 meterbaan heb ik een camera systeem op elke schiet punt met monitor gemaakt.
dit heb ik aangestuurd via een RC zender met 6 servo's.
maar dit heeft eigenlijk nooit echt goed gewerkt.
de ontvang kreeg te veel storing binnen waardoor de servo's aan het trillen waren.

nu heb ik bij alles gesloopt.
alleen de servo zitten er nog.

nu wil ik meteen Arduino mega dit gaan maken.

met hulp van google heb ik dit tot nu gemaakt.

Code: Alles selecteren
// By Henk van Bergen
// 17-09-2016
// Voor 100 meter schietbaan SV Gennep.
// Camera besturing schietdoelen op 100 meter



#include<Servo.h>
int pos1 = 13;              // startpositie servo 1
int pos2 = 50;              // startpositie servo 2
int pos3 = 13;              // startpositie servo 3
int pos4 = 50;              // startpositie servo 4
int pos5 = 13;              // startpositie servo 5
int pos6 = 50;              // startpositie servo 6

Servo servo1;               // Servo naam 1
Servo servo2;               // Servo naam 2
Servo servo3;               // Servo naam 3
Servo servo4;               // Servo naam 4
Servo servo5;               // Servo naam 5
Servo servo6;               // Servo naam 6

void setup() {

  pinMode(2, INPUT);        // servo 1 links
  pinMode(3, INPUT);        // servo 1 rechts
  servo1.attach(7);         // plus draad servo 1

  pinMode(4, INPUT);        // servo 2 links
  pinMode(5, INPUT);        // servo 2 rechts
  servo2.attach(6);         // plus draad servo 2
}

void loop() {
  if (digitalRead(3) == HIGH && pos1 < 180) {      // servo 1 links motor
    pos1++;
    servo1.write(pos1);
    delay(5);
  }

  if (digitalRead(2) == HIGH && pos1 > 18)  {      // servo 1 rechts motor
    pos1--;
    servo1.write(pos1);
    delay(5);
  }

  if (digitalRead(5) == HIGH && pos2 < 180) {      // servo 2 links motor
    pos2++;
    servo2.write(pos2);
    delay(5);
  }

  if (digitalRead(4) == HIGH && pos2 > 0)  {      // servo 2 rechts motor
    pos2--;
    servo2.write(pos2);
    delay(5);
  }
}


voor zover werkt dit goed.

ik weet dat de code nog niet af is aangezien er nog behoorlijk wat mist.
maar met 2 servo's kan een proef opstelling maken op de schietbaan.




wat vinden jullie zover van dit??

wat ik nog graag zou willen is het volgende.

dat een servo als hij niet gebruikt word automatische na bv 30 min uitgaat. om de slijtage tegen te gaan, de servo staat namelijk constant onder belasting.
en natuurlijk de andere servo die in gebruik zijn gewoon doorwerken.

dus even een voorbeeld:
baan 1 is aan het schieten en bedient de servo.
baan 2 ook
baan 3 ligt niemand te schieten dus deze mag uit
baan 4 ook uit.
enz

maar als er nu iemand op baan 4 gaat schieten dat hij de servo activeert door een van de knoppen te bedienen.
en zo lang hij het binnen 30 min blijft gebruiken dat deze niet uitgaat.

volgens mij is dat lastig te maken..
maar misschien ook niet aangezien ik er bijna nog ervaring mee heb.

nu mijn laatste vraag.

je heb analoge servo en digitale servo's
kan ik ook een digitale servo op de Arduino aansluiten.
in deze opstelling.

alvast hartelijk bedankt voor jullie hulp en info

gr.
henk

Advertisement

Berichten: 2130
Geregistreerd: 16 Okt 2013, 14:31
Woonplaats: s hertogenbosch

Re: helemaal nieuw hier, ik heb klein servo project

Berichtdoor shooter » 18 Sep 2016, 16:40

Een servo uitzetten kan eigenlijk alleen maar als je de voeding uitzet, (met een relais bijv. )
dat betekent dus een extra uitgang op de MEGA voor elke servo.
is geen probleem hoor.
ook de 30 minuten is geen probleem. gebruik daar een timer voor (lees blink without delay)

je zult wel een ander soort programa gaan schrijven, want nu is het zo dat elke servo achter elkaar staat en een hoop tijd gaat vragen.
zorg dat de loop erg snel doorlopen wordt, en dan een stel functies aanroept als er een knop ingedrukt wordt. In de functie wordt dan gekeken of de staptijd al voorbij is en dan wordt de servo verzet.

als je niet vastzit aan de servos, dan kun je ook een stappenmotor gebruiken, die kun je door de software uit zetten, maar het vraagt dan wel een extra printje om de signalen te versterken.
maar dat ligt vooral aan wat je al in huis hebt.
paul deelen
shooter@home.nl

Gebruikers-avatar
Berichten: 5
Geregistreerd: 17 Sep 2016, 20:31
Woonplaats: groesbeek

Re: helemaal nieuw hier, ik heb klein servo project

Berichtdoor Henkie » 18 Sep 2016, 21:33

dankjewel shooter,

ik heb de servo er al zitten.
dus ik zou hier graag op door willen borduren.
ik ga het even doornemen van dat blink without delay

dat met die doorloop tijd had ik ook al gemerkt.

is dat simpel op te lossen,want ik denk dat dit met 6 servo's aardig traag zal gaan worden.
ik heb er helaas nog te weinig kennis van.
dus hulp zou heel welkom zijn.

weet jij trouwens welk boek ik het besten kan kopen om de begrippen in op te zoeken.
want ik wil niet alles van google leren.

thanks

gr.
henk

Gebruikers-avatar
Berichten: 5
Geregistreerd: 17 Sep 2016, 20:31
Woonplaats: groesbeek

Re: helemaal nieuw hier, ik heb klein servo project

Berichtdoor Henkie » 19 Sep 2016, 00:01

is het mogelijk dat jullie mij kant opsturen, want ik allemaal nodig heb om dit goed te kunnen maken.
ik verwacht geen kant en klare code ( zou wel leuk zijn :D )

maar een paar code maar ik mee kan stoeien.

ik merk namelijk dat die code van mij toch wel wat kleine problemen met zich mee draagt, zoals de delay die alle servo gaan krijgen.

alle hulp is welkom.

alvast bedankt voor jullie moeite.


gr.
henk

Berichten: 2130
Geregistreerd: 16 Okt 2013, 14:31
Woonplaats: s hertogenbosch

Re: helemaal nieuw hier, ik heb klein servo project

Berichtdoor shooter » 20 Sep 2016, 13:11

voor boeken kijk in een ander subject.
paul deelen
shooter@home.nl

Gebruikers-avatar
Berichten: 4
Geregistreerd: 02 Sep 2016, 20:17

Re: helemaal nieuw hier, ik heb klein servo project

Berichtdoor Adam69 » 20 Okt 2016, 16:33

Beste Henk,

Hierbij een voorbeeld Sketch.
Klopt... het is nog niet af en zeker niet perfect, maar heeft toch al aardig wat zaken erin zitten.
zoals Shooter mooi heeft aangegeven:
Een servo uitzetten kan eigenlijk alleen maar als je de voeding uitzet, (met een relais bijv. )

Dus heb ik een extra Pin gebruikt om voor elke Servo de Stroom eraf te kunnen halen (middels een Relais).

De aantal Pins die je zo in gebruik hebt loopt wel aardig op en ik stel eigenlijk voor, om per Servo's een eigen Arduino in te zetten. De prijs van die dingen is erg laag en maakt het makkelijk bij uitval/onderhoud.

Je kan ook best werken met 1 Arduino, echter bij veel servo's heb je geen digitale Pin meer vrij voor de volgende Servo, die je wil inzetten.
Een oplossing kan zijn, dat je de drukknoppen samenvoegt op een analoge Pin, in plaats van ieder zijn eigen digitale Pin, zou je bijvoorbeeld 4 drukknoppen per analoge Pin kunnen aansluiten (dus 2 servo's bedienen, met 1 pin)
Elke Drukknop krijgt dan een weerstand (elke net een andere waarde), en samen aangesloten op de analoge pin.
Door de waarde op de analoge Pin uit te lezen weet je welke Drukknop het was, hiervan zijn best veel demo's te vinden, mocht je die kant op willen.

Maar goed, bij deze de voorbeeld Sketch:
cpp code
// By Henk van Bergen
// 17-09-2016
// Voor 100 meter schietbaan SV Gennep.
// Camera besturing schietdoelen op 100 meter


// Algemene informatie en instellingen
const int DraaiLinks = 1;
const int DraaiRechts = -1;
unsigned long ServoTimer= 1800000; // Timer in ms (1000 = 1 seconde) en (60000 = 1 minuut) en (1800000 = 30 minuten)
// Als deze timer verloopt, gaat de stroom van de Servo (tijd is dus voor alle Servo's gelijk)

#include <Servo.h>

// alles wat te maken heeft met servo 1
Servo servo1; // Servo naam 1
int Servo1Pos = 0; // Bijhouden waar de Servo 1 nu staat
const int ServoPin1 = 7; // Servo aangesloten op digitale PIN
const int Startpos1 = 13; // Startpositie servo 1
const int Maxpos1 = 180; // Draai servo 1 maximale waarde
const int Minpos1 = 18; // Draai servo 1 minimale waarde
const int KnopLinks1 = 2; // Bedien Servo 1 met Knop Links
const int KnopRechts1 = 3; // Bedien Servo 1 met Knop Rechts
const int ServoStroom1 = 8; // Servo 1 relais Pin, om stroom erop te zetten of eraf te halen (aan= HIGH, uit= LOW)
unsigned long ServoRust1 = 0; // Bijhouden hoe lang de Servo 1 al niet in gebruik is.

// alles wat te maken heeft met servo 2
Servo servo2; // Servo naam 2
int Servo2Pos = 0; // Bijhouden waar de Servo 2 nu staat
const int ServoPin2 = 6; // Servo aangesloten op digitale PIN
const int Startpos2 = 50; // Startpositie Servo 2
const int Maxpos2 = 180; // Draai Servo 2 maximale waarde
const int Minpos2 = 0; // Draai Servo 2 minimale waarde
const int KnopLinks2 = 4; // Bedien Servo 2 met Knop Links
const int KnopRechts2 = 5; // Bedien Servo 2 met Knop Rechts
const int ServoStroom2 = 9; // Servo 2 relais Pin, om stroom erop te zetten of eraf te halen (aan= HIGH, uit= LOW)
unsigned long ServoRust2 = 0; // Bijhouden hoe lang de Servo 2 al niet in gebruik is.

// Natuurlijk kan je hier nog meer servo's toevoegen
// maak een copy van een van de servo's hierboven
// en pas de waarden aan voor de nieuwe servo



void setup ()
{
// Zet de configuratie klaar voor Servo 1
servo1.attach (ServoPin1); // Plus draad Servo 1
pinMode (KnopLinks1, INPUT); // Bedien knop Links voor Servo 1
pinMode (KnopRechts1, INPUT); // Bedien knop Rechts voor Servo 1
digitalWrite (ServoStroom1, HIGH); // Zet stroom op de Servo 1
Servo1Pos = Startpos1; // Bijhouden waar de Servo 1 nu staat
servo1.write (Startpos1); // Plaats de Servo 1 in de begin positie
delay (100); // Kleine pauze zodat servo naar begin positie kan
ServoRust1 = millis(); // Bewaar de timer voor Servo 1
digitalWrite (ServoStroom1, LOW); // Haal stroom van Servo 1 af, direct naar rust stand

// Zet de configuratie klaar voor Servo 2
servo2.attach (ServoPin2); // Plus draad Servo 2
pinMode (KnopLinks2, INPUT); // Servo 2 Links
pinMode (KnopRechts2, INPUT); // Servo 2 Rechts
digitalWrite (ServoStroom2, HIGH); // Zet stroom op de Servo 2
Servo2Pos = Startpos2; // Bijhouden waar de Servo 2 nu staat
servo2.write (Startpos2); // Plaats de Servo 2 in de begin positie
delay (100); // Kleine pauze zodat servo naar begin positie kan
ServoRust2 = millis(); // Bewaar de timer voor Servo 2
digitalWrite (ServoStroom2, LOW); // Haal stroom van Servo 2 af, direct naar rust stand

// Heb je meer dan de 2 Servo's, dan moet je hier ook meer servo's klaarzetten
// maak een copy van een van de servo instellingen hierboven
// en pas de waarden aan voor de nieuwe servo
}



void loop ()
{
// Bediening voor de knoppen van Servo 1
if ( (digitalRead (KnopLinks1) == HIGH) && ((digitalRead (KnopRechts1) == LOW ) && Servo1Pos< Maxpos1) ) { Servo1Pos+= DraaiLinks; }
if ( (digitalRead (KnopLinks1) == LOW ) && ((digitalRead (KnopRechts1) == HIGH) && Servo1Pos< Maxpos1) ) { Servo1Pos+= DraaiRechts; }
if ( (digitalRead (KnopLinks1) == HIGH) || (digitalRead (KnopRechts1) == HIGH) )
{
digitalWrite (ServoStroom1, HIGH); // Zet stroom op de Servo 1
servo1.write (Servo1Pos); // Draai Servo 1 naar de nieuwe positie
ServoRust1= millis (); // Start de timer opnieuw, om later de stroom er af te halen
}

// Bediening voor de knoppen van Servo 2
if ( (digitalRead (KnopLinks2) == HIGH) && ((digitalRead (KnopRechts2) == LOW ) && Servo2Pos< Maxpos2) ) { Servo2Pos+= DraaiLinks; }
if ( (digitalRead (KnopLinks2) == LOW ) && ((digitalRead (KnopRechts2) == HIGH) && Servo2Pos< Maxpos2) ) { Servo2Pos+= DraaiRechts; }
if ( (digitalRead (KnopLinks2) == HIGH) || (digitalRead (KnopRechts2) == HIGH) )
{
digitalWrite (ServoStroom2, HIGH); // Zet stroom op de Servo 2
servo2.write (Servo2Pos); // Draai Servo 2 naar de nieuwe positie
ServoRust2= millis (); // Start de timer opnieuw, om later de stroom er af te halen
}

// Heb je meer dan de 2 Servo's, dan moet je hier ook de bediening van de servo's toevoegen
// maak een copy van een van de servo bediening hierboven
// en pas de waarden aan voor de nieuwe servo

// Wacht tot de servo is gedraaid
delay (10);

// Is er een Servo die al enige tijd niet in gebruikt is ?, dan kan de stroom er wel vanaf
if ( (ServoRust1!= 0) && ((millis()- ServoRust1)> ServoTimer) )
{
servo1.write (Startpos1); // Plaats de Servo 1 in de begin positie
Servo1Pos = Startpos1; // Bijhouden waar de Servo 1 nu staat
delay (500); // Kleine pauze zodat servo naar begin positie kan
digitalWrite (ServoStroom1, LOW); // Stroom gaat er bij Servo 1 af
ServoRust1= 0; // Timer is gestopt
}

if ( (ServoRust2!= 0) && ((millis()- ServoRust2)> ServoTimer) )
{
servo2.write (Startpos2); // Plaats de Servo 2 in de begin positie
Servo2Pos = Startpos2; // Bijhouden waar de Servo 2 nu staat
delay (500); // Kleine pauze zodat servo naar begin positie kan
digitalWrite (ServoStroom2, LOW); // Stroom gaat er bij Servo 2 af
ServoRust2= 0; // Timer is gestopt
}

// Heb je meer dan de 2 Servo's, dan moet je ook hier de timer van de nieuwe servo toevoegen
// maak een copy van een van de servo timer hierboven
// en pas de waarden aan voor de nieuwe servo
}


Zoals je ongeveer kan zien bestaat het uit 3 blokken, allemaal waardes en instellingen per Servo.
Dan komt de Setup waarin alles bij het opstarten van de Arduino klaar gezet wordt.
En als laatste stuk, de Loop, waarin alles gebeurd als de Arduino aan staat.

Eigenlijk bestaat dit laatste ook weer uit 2 stukken, eerst controleren of er op de drukknoppen is gedrukt en de acties daarbij uitvoeren, en daarna controleren of er ergens de stroom af kan, omdat de Servo al enige tijd niet in gebruik is.

Wat zelf het meeste hoop, is dat het commentaar dat erbij staat je verder helpt met het programmeren van de Arduino en het zelf aanpassen naar eigen behoefte hiervan.

Succes met je project

Adam

Berichten: 25
Geregistreerd: 16 Jun 2016, 21:23

Re: helemaal nieuw hier, ik heb klein servo project

Berichtdoor john33 » 01 Nov 2016, 21:16

Een analoge of een digitale servo maakt voor de Arduino niet uit.
Bij een project van mijzelf merkte ik dat digitale servo`s minder storingsgevoelig zijn dan eenvoudige analoge.

Je kunt ook met een timer misschien kijken of je de uitgaande digitale poort kunt afzetten in plaats van de voeding er af halen.
Ik heb ergens volgens mij zo iets gelezen, dat je een poort "uit" kunt zetten, maar vraag me niet hoe.

Maar digitale en analoge servo`s zijn gewoon zonder extra poespas te gebruiken.

Gebruikers-avatar
Berichten: 5
Geregistreerd: 17 Sep 2016, 20:31
Woonplaats: groesbeek

Re: helemaal nieuw hier, ik heb klein servo project

Berichtdoor Henkie » 19 Apr 2017, 21:58

beste mensen,

het is al weer een tijdje geleden.

ik heb ondertussen een nieuwe code geschreven met hulp van andere.

maar ik loop tegen een probleempje aan.

wat ik zover heb werkt goed.

wat heb ik nu gemaakt.

op de schietbaan hebben 6 camera's zitten die op 6 servo's zitten aangesloten.
voor 6 schieten punten.
door middel van een druk knop kunnen ze de camera op 100 meter besturen.
2 druk schakelaars up/down per baan.

dit werkt allemaal.
maar wat ik nu wil is dat de servo's na 45 min in een rust stand gaan staan.
drukken de mensen nu binnen die 45 min op een van de knoppen dan reset die teller van die baan weer.

nu het probleem
ik gebruik het commando

Code: Alles selecteren
int maximum_idle_time = 30000;


ik de tijd te bepalen
maar als ik boven de 32000 kom werkt het niet meer
ik weet dat dit komt door de 16 bit.

maar iemand zei tegen mij dan ik in plaats van int float moest gebruiken maar helaas werkt dit ook niet.

heeft iemand een idee??

Code: Alles selecteren
/* Sweep
  servo besturing 100 meter.
  voor SV Gennep
  By Henk & Rob & Rik
  18-4-2017
*/

//led pin output
int led = 13;
int led2 = 12;

#include <Servo.h>

Servo myservo_1;  // Maak servo besturing baan 1
Servo myservo_2;  // Maak servo besturing baan 2
Servo myservo_3;  // Maak servo besturing baan 3
Servo myservo_4;  // Maak servo besturing baan 4
Servo myservo_5;  // Maak servo besturing baan 5
Servo myservo_6;  // Maak servo besturing baan 6

int start_pos_1 = 1500;    // Start positie waar de servo 1 uitstart. Deze kan je gelijk maken aan de slaap positie.
int start_pos_2 = 1500;    // Start positie waar de servo 2 uitstart. Deze kan je gelijk maken aan de slaap positie.
int start_pos_3 = 1500;    // Start positie waar de servo 3 uitstart. Deze kan je gelijk maken aan de slaap positie.
int start_pos_4 = 1500;    // Start positie waar de servo 4 uitstart. Deze kan je gelijk maken aan de slaap positie.
int start_pos_5 = 1500;    // Start positie waar de servo 5 uitstart. Deze kan je gelijk maken aan de slaap positie.
int start_pos_6 = 1500;    // Start positie waar de servo 6 uitstart. Deze kan je gelijk maken aan de slaap positie.

int actual_pos_1 = start_pos_1;    // variable to store the actual servo position. Gelijk maken aan start positie voor soepelere start
int actual_pos_2 = start_pos_2;    // variable to store the actual servo position. Gelijk maken aan start positie voor soepelere start
int actual_pos_3 = start_pos_3;    // variable to store the actual servo position. Gelijk maken aan start positie voor soepelere start
int actual_pos_4 = start_pos_4;    // variable to store the actual servo position. Gelijk maken aan start positie voor soepelere start
int actual_pos_5 = start_pos_5;    // variable to store the actual servo position. Gelijk maken aan start positie voor soepelere start
int actual_pos_6 = start_pos_6;    // variable to store the actual servo position. Gelijk maken aan start positie voor soepelere start

int idle_counter_1 = 0; // variable to store the idle time
int idle_counter_2 = 0; // variable to store the idle time
int idle_counter_3 = 0; // variable to store the idle time
int idle_counter_4 = 0; // variable to store the idle time
int idle_counter_5 = 0; // variable to store the idle time
int idle_counter_6 = 0; // variable to store the idle time

int max_pos_1 = 1800;    // Maximale positie servo 1, C in tekening
int max_pos_2 = 1800;    // Maximale positie servo 2, C in tekening
int max_pos_3 = 1800;    // Maximale positie servo 3, C in tekening
int max_pos_4 = 1800;    // Maximale positie servo 4, C in tekening
int max_pos_5 = 1800;    // Maximale positie servo 5, C in tekening
int max_pos_6 = 1800;    // Maximale positie servo 6, C in tekening

int min_pos_1 = 1400;    // Minimale positie servo 1, B in tekening
int min_pos_2 = 1400;    // Minimale positie servo 2, B in tekening
int min_pos_3 = 1400;    // Minimale positie servo 3, B in tekening
int min_pos_4 = 1400;    // Minimale positie servo 4, B in tekening
int min_pos_5 = 1400;    // Minimale positie servo 5, B in tekening
int min_pos_6 = 1400;    // Minimale positie servo 6, B in tekening

int sleep_pos_1 = 1380;    // Slaap positie servo 1, A in tekening
int sleep_pos_2 = 1380;    // Slaap positie servo 2, A in tekening
int sleep_pos_3 = 1380;    // Slaap positie servo 3, A in tekening
int sleep_pos_4 = 1380;    // Slaap positie servo 4, A in tekening
int sleep_pos_5 = 1380;    // Slaap positie servo 5, A in tekening
int sleep_pos_6 = 1380;    // Slaap positie servo 6, A in tekening


int maximum_idle_time = 30000;     //Maximale tijd waarna een servo terugstuurt naar slaap positie. Deze waarde delen door 1000 is minuten.


void setup() {

  //led1,2 output
  pinMode(led, OUTPUT);
  pinMode(led2, OUTPUT);
 
  //servo 1
  pinMode(52, INPUT_PULLUP);
  pinMode(53, INPUT_PULLUP);
  //servo 2
  pinMode(50, INPUT_PULLUP);
  pinMode(51, INPUT_PULLUP);
  //servo 3
  pinMode(48, INPUT_PULLUP);
  pinMode(49, INPUT_PULLUP);
  //servo 4
  pinMode(46, INPUT_PULLUP);
  pinMode(47, INPUT_PULLUP);
  //servo 5
  pinMode(44, INPUT_PULLUP);
  pinMode(45, INPUT_PULLUP);
  //servo 6
  pinMode(42, INPUT_PULLUP);
  pinMode(43, INPUT_PULLUP);

  //servo 1
  myservo_1.attach(30);                         // attaches the servo on pin 30 to the servo object
  myservo_1.writeMicroseconds(actual_pos_1);

  //servo 2
  myservo_2.attach(31);                         // attaches the servo on pin 31 to the servo object
  myservo_2.writeMicroseconds(actual_pos_2);

  //servo 3
  myservo_3.attach(32);                         // attaches the servo on pin 32 to the servo object
  myservo_3.writeMicroseconds(actual_pos_3);

  //servo 4
  myservo_4.attach(33);                         // attaches the servo on pin 33 to the servo object
  myservo_4.writeMicroseconds(actual_pos_4);

  //servo 5
  myservo_5.attach(34);                         // attaches the servo on pin 34 to the servo object
  myservo_5.writeMicroseconds(actual_pos_5);

  //servo 6
  myservo_6.attach(35);                         // attaches the servo on pin 35 to the servo object
  myservo_6.writeMicroseconds(actual_pos_6);



 Serial.begin(9600);

}


void loop()
{
// the loop routine runs over and over again forever:
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(50);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);
  {digitalWrite(led2, HIGH);
delay(50);
digitalWrite(led2, LOW);
delay(1000);}



// servo 1
  {
    if (digitalRead(52) == 0) {                               //Switch pulls input to ground
      myservo_1.writeMicroseconds(actual_pos_1);              //Stuur 'actual_pos_1' naar servo
      idle_counter_1 = 0;                                     //Slaap teller weer op 0 als deze servo wordt bestuurd
      if(actual_pos_1<max_pos_1){                             //Als de huidige uitslag lager is dan maximale toegestane uitslag, dan
        actual_pos_1++;                                       //+1 stapje
      }
     
    }
    if (digitalRead(53) == 0) {                               //Switch pulls input to ground
      myservo_1.writeMicroseconds(actual_pos_1);              // tell servo to go to position in variable 'actual_pos_1'
        if(actual_pos_1>min_pos_1){                           //Als de huidige uitslag hoger is dan minimale toegestane uitslag, dan -1 stapje
        actual_pos_1--;
      }
    }
   
    if (idle_counter_1 > maximum_idle_time) {                 //Wanneer de idle counter hoger is dan de maximale waarde:
      while(sleep_pos_1<actual_pos_1) {                       //Dan, zolang de actual positie hoger is dan slaap positie
        delay(10);                                            //Met een vertraging van 10 micro seconde
        actual_pos_1--;                                       //De huidige positie verlagen met 1 tot deze gelijk is aan slap positie
        myservo_1.writeMicroseconds(actual_pos_1);            //POsitie naar servo schrijven
      }
    }
// servo 2
 
    if (digitalRead(50) == 0) {                               //Switch pulls input to ground
      myservo_2.writeMicroseconds(actual_pos_2);
      idle_counter_2 = 0;                                     
      if(actual_pos_2<max_pos_2){                             //Als de huidige uitslag lager is dan maximale toegestane uitslag, dan +1 stapje
        actual_pos_2++;                                       // tell servo to go to position in variable 'actual_pos_2'
      }
      //Serial.println(actual_pos_2);
    }
    if (digitalRead(51) == 0) {                               //Switch pulls input to ground
      myservo_2.writeMicroseconds(actual_pos_2);              // tell servo to go to position in variable 'actual_pos_2'
      if(actual_pos_2>min_pos_2){                             //Als de huidige uitslag hoger is dan minimale toegestane uitslag, dan -1 stapje
        actual_pos_2--;
      }
      //Serial.println(actual_pos_2);
    }
    if (idle_counter_2 > maximum_idle_time) {                 //Wanneer de idle counter hoger is dan de maximale waarde:
      while(sleep_pos_2<actual_pos_2) {                       //Dan, zolang de actual positie hoger is dan slaap positie
        delay(10);                                            //Met een vertraging van 10 micro seconde
        actual_pos_2--;                                       //De huidige positie verlagen met 1 tot deze gelijk is aan slap positie
        myservo_2.writeMicroseconds(actual_pos_2);            //POsitie naar servo schrijven
      }
    }
    }
   
   
// servo 3
 
    if (digitalRead(48) == 0) {                               //Switch pulls input to ground
      myservo_3.writeMicroseconds(actual_pos_3);             
      idle_counter_3 = 0;
      if(actual_pos_3<max_pos_3){                             //Als de huidige uitslag lager is dan maximale toegestane uitslag, dan +1 stapje
        actual_pos_3++;                                       // tell servo to go to position in variable 'actual_pos_3'
      }
    }
    if (digitalRead(49) == 0) {                               //Switch pulls input to ground
      myservo_3.writeMicroseconds(actual_pos_3);              // tell servo to go to position in variable 'actual_pos_3'
     idle_counter_3 = 0;
      if(actual_pos_3>min_pos_3){                             //Als de huidige uitslag hoger is dan minimale toegestane uitslag, dan -1 stapje
        actual_pos_3--;
      }
    }
    if (idle_counter_3 > maximum_idle_time) {                 //Wanneer de idle counter hoger is dan de maximale waarde:
      while(sleep_pos_3<actual_pos_3) {                       //Dan, zolang de actual positie hoger is dan slaap positie
        delay(10);                                            //Met een vertraging van 10 micro seconde
        actual_pos_3--;                                       //De huidige positie verlagen met 1 tot deze gelijk is aan slap positie
        myservo_3.writeMicroseconds(actual_pos_3);            //POsitie naar servo schrijven
      }
    }

// servo 4
 
    if (digitalRead(46) == 0) {                               //Switch pulls input to ground
      myservo_4.writeMicroseconds(actual_pos_4);             
      idle_counter_4 = 0;
      if(actual_pos_4<max_pos_4){                             //Als de huidige uitslag lager is dan maximale toegestane uitslag, dan +1 stapje
        actual_pos_4++;                                       // tell servo to go to position in variable 'actual_pos_4'
      }
    }
    if (digitalRead(47) == 0) {                               //Switch pulls input to ground
      myservo_4.writeMicroseconds(actual_pos_4);              // tell servo to go to position in variable 'actual_pos_4'
     idle_counter_4 = 0;
      if(actual_pos_4>min_pos_4){                             //Als de huidige uitslag hoger is dan minimale toegestane uitslag, dan -1 stapje
        actual_pos_4--;
      }
    }
    if (idle_counter_4 > maximum_idle_time) {                 //Wanneer de idle counter hoger is dan de maximale waarde:
      while(sleep_pos_1<actual_pos_4) {                       //Dan, zolang de actual positie hoger is dan slaap positie
        delay(10);                                            //Met een vertraging van 10 micro seconde
        actual_pos_4--;                                       //De huidige positie verlagen met 1 tot deze gelijk is aan slap positie
        myservo_4.writeMicroseconds(actual_pos_4);            //POsitie naar servo schrijven
      }
    }

// servo 5
 
    if (digitalRead(44) == 0) {                               //Switch pulls input to ground
      myservo_5.writeMicroseconds(actual_pos_5);              // tell servo to go to position in variable 'actual_pos_5'
      idle_counter_5 = 0;
      if(actual_pos_5<max_pos_5){                             //Als de huidige uitslag lager is dan maximale toegestane uitslag, dan +1 stapje
        actual_pos_5++;
      }
    }
    if (digitalRead(45) == 0) {                               //Switch pulls input to ground
      myservo_5.writeMicroseconds(actual_pos_5);              // tell servo to go to position in variable 'actual_pos_5'
     idle_counter_5 = 0;
      if(actual_pos_5>min_pos_5){                             //Als de huidige uitslag hoger is dan minimale toegestane uitslag, dan -1 stapje
        actual_pos_5--;
      }
    }

    if (idle_counter_5 > maximum_idle_time) {                 //Wanneer de idle counter hoger is dan de maximale waarde:
      while(sleep_pos_5<actual_pos_5) {                       //Dan, zolang de actual positie hoger is dan slaap positie
        delay(10);                                            //Met een vertraging van 10 micro seconde
        actual_pos_5--;                                       //De huidige positie verlagen met 1 tot deze gelijk is aan slap positie
        myservo_5.writeMicroseconds(actual_pos_5);            //POsitie naar servo schrijven
      }
    }

// servo 6
 
    if (digitalRead(42) == 0) {                               //Switch pulls input to ground
      myservo_6.writeMicroseconds(actual_pos_6);             
      idle_counter_6 = 0;
      if(actual_pos_6<max_pos_6){                             //Als de huidige uitslag lager is dan maximale toegestane uitslag, dan +1 stapje
        actual_pos_6++;                                       // tell servo to go to position in variable 'actual_pos_6'
      }
    }
    if (digitalRead(43) == 0) {                               //Switch pulls input to ground
      myservo_6.writeMicroseconds(actual_pos_6);              // tell servo to go to position in variable 'actual_pos_6'
      idle_counter_6 = 0;
      if(actual_pos_6>min_pos_6){                             //Als de huidige uitslag hoger is dan minimale toegestane uitslag, dan -1 stapje
        actual_pos_6--;
      }
    }

    if (idle_counter_6 > maximum_idle_time) {                 //Wanneer de idle counter hoger is dan de maximale waarde:
     while(sleep_pos_6<actual_pos_6) {                       //Dan, zolang de actual positie hoger is dan slaap positie
     delay(10);                                            //Met een vertraging van 10 micro seconde
    actual_pos_6--;                                       //De huidige positie verlagen met 1 tot deze gelijk is aan slap positie
     myservo_6.writeMicroseconds(actual_pos_6);            //POsitie naar servo schrijven
     }
    }

    delay(25); //Total loop delay in milliseconds. Smaller value = quicker movement

    idle_counter_1++;                         //Hier worden alle slaap timers opgehoogd.
    idle_counter_2++;                         //In de functies hierboven worden ze vergeleken met de max waarde en zonodig na beweging terug gezet
    idle_counter_3++;
    idle_counter_4++;
    idle_counter_5++;
    idle_counter_6++;

  }
 
 

   



alvast bedankt


gr.
henk

Berichten: 2130
Geregistreerd: 16 Okt 2013, 14:31
Woonplaats: s hertogenbosch

Re: helemaal nieuw hier, ik heb klein servo project

Berichtdoor shooter » 24 Apr 2017, 09:48

maak er unsigned long van die is dubbel zo breed.
verder zou ik al die delays eruit halen, want nu worden de digitalreads heel langzaam gelezen.
ik zou ook zeker gaan denken aan een array waarin bijvoorbeeld de pinnen staan maar ook de tijden en de servos.

dan hoef je de routine ook maar 1 keer te schrijven (en dan roep je gewoon 6 keer dezelfde functie aan.
paul deelen
shooter@home.nl

Gebruikers-avatar
Berichten: 5
Geregistreerd: 17 Sep 2016, 20:31
Woonplaats: groesbeek

Re: helemaal nieuw hier, ik heb klein servo project

Berichtdoor Henkie » 24 Apr 2017, 10:19

dankjewel Shooter,
ik ga het even testen.

wat betreft die delays.
daar ga ik ook met spelen.
maar mijn kennis is nog niet op zo'n hoog nivo :D
thanks.

gr.
henk

Terug naar Overige projecten

Wie is er online?

Gebruikers in dit forum: Geen geregistreerde gebruikers en 1 gast