Hoe kan ik een geschutstoren 290 graden laten draaien

Jawel hoor Ernst, zie post 17 van dit draadje, maar ik vrees dat dan het servohuis niet meer dicht kan, en dat lost het probleem van de draaisnelheid niet op, die in tegenstelling van gebruikelijk (zo snel mogelijk) in dit geval liever tergend langzaam is.

 

Dit is nieuw terrein voor mij, daar moet ik eens op gaan studeren. Later meer dus.

Vertel eens hoeveel je er eigenlijk nodig hebt, de UNO heeft 20 digitale poorten (inclusief de Ax poorten), waarvan je er maar één in beslag neemt voor verbinding met de Rx, of mogelijk 2 (interrupt poorten 2 en 3), dus heb je er minimaal 18 tot je beschikking voor servo's......

 

het is vooral voor de vereenvoudiging van de bedrading geen 8 aftakkingen van GND en 5V meer en slechts 2 signaalkabels, waarvoor op de UNO speciale aansluitingen voorzien zijn (SDA en .SCL)
Voor de 4 geschutstorens voorzie ik 8 servo's, maar nu we toch bezig zijn, behoort het draaien van de radarunits ook tot de mogelijkheid, en wat verlichting mag er ook op.
Ik weet dus waarmee ik wil beginnen, maar waar het eindigt? ...

 

Diezelfde aftakkingen krijg je nu vanaf de Adafruit module, het enige voordeel is dat het aftakken in de module zelf gebeurt. Maar een aftak-printje maken van een stukje experimenteer-printbord en een setje aansluitpennetjes is ook zo gebeurd hoor......
(tenzij je net zo'n hekel aan solderen hebt als ik )

 

Ok, over de Adafruit module: Mijn wijsheid komt HIER vandaan.
In principe werkt de module op dezelfde manier als de standaard Servo_h library die ik tot nu toe toegepast heb, alleen met een aparte processor. Je moet wel een andere library installeren zoals op de eerste pagina beschreven wordt.

Ik heb de voorbeeld-sketch op GitHub gevonden, en aangepast/ingekort zodat deze straks makkelijk te integreren is in mijn code:

Code:

/***************************************************
  This is an example for our Adafruit 16-channel PWM & Servo driver
  Servo test - this will drive 8 servos, one after the other on the
  first 8 pins of the PCA9685
 ****************************************************/

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

#define USMIN  600 // This is the rounded 'minimum' microsecond length
#define USMAX  2400 // This is the rounded 'maximum' microsecond length

// servo # counter
uint8_t servonum = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("8 channel Servo test!");

  pwm.begin();

  pwm.setOscillatorFrequency(27000000); // tune any output to 50Hz using oscilloscope to get precise microseconds
  pwm.setPWMFreq(50);  // Analog servos run at ~50 Hz updates

  delay(10);
}


void loop() {
  Serial.println(servonum);

  // Drive each servo one at a time using writeMicroseconds(), it's not precise due to calculation rounding!
  // The writeMicroseconds() function is used to mimic the Arduino Servo library writeMicroseconds() behavior.
  for (uint16_t microsec = USMIN; microsec < USMAX; microsec++) {
    pwm.writeMicroseconds(servonum, microsec);
  }

  delay(500);
  for (uint16_t microsec = USMAX; microsec > USMIN; microsec--) {
    pwm.writeMicroseconds(servonum, microsec);
  }

  delay(500);

  servonum++;
  if (servonum > 7) servonum = 0; // Testing the first 8 servo channels
}

Ik stel voor dat je om te beginnen deze code draait met de UNO/Adafruit, om te zien of het allemaal soepel loopt.

I heb nog steeds geen helder beeld van de manier waarop jij de voeding gerealiseerd hebt, ik heb nog steeds de indruk dat je geen compleet onafhankelijke voedingsbronnen voor de UNO en voor de servo's gebruikt, maar misschien heb ik dat mis. Dus stel ik, misschien ten overvloede, voor om het volgende schema te volgen:
- gebruik een 9V batterij voor de UNO, en koppel die via de Vcc aansluitingen door naar de Adafruit, zoals in het web-artikel vermeld wordt.
- gebruik een aparte 5V of 6V voeding van voldoende capaciteit en sluit die aan op de blauwe klemmenstrook van de Adafruit.

 

Ik heb nog een regeltje toegevoegd om het servonummer via de monitor te tonen.

Verder valt me op dat er geen initiële pulswaardes aan alle servo's toegewezen worden, misschien doet de Adafruit dat zelf. Check eens of de nog niet aangestuurde servo's vooreerst "slap" blijven.

 

Vooreerst @max z hartelijk dank voor de snelle reactie, ik dacht dat je daar wel een weekje over zou doen, vermits je er nog geen ervaring mee hebt, en de module dus waarschijnlijk niet in huis hebt.
Wat betreft de stroomaansluiting: je indruk is helemaal correct, maar de servo's krijgen geen stroom via de UNO, maar via de stroombron die 5V geeft via een adapter, en de UNO is op diezelfde stroombron aangesloten. Ik bemerk wel dat als de servo's draaien, de oranje LED op de UNO lichtjes knippert.
Dus heb ik eerst je aanbeveling opgevolgd, en de 5V kabel uit de UNO verwijderd en een vers van de lader genomen oplaadbare 9V batterij aangesloten.
Om hysterisch van te worden: totaal oncontroleerbare beweging van de servo's is het gevolg (GND heb ik blijven zitten tussen UNO en breadboard met de servo's,
Conclusie: onafhankelijke stroombron voor de UNO is geen oplossing met code uit post 108.

Dan heb ik de code uit post 126 opgeladen.
Aansluitingen:
Externe voeding 5V via adapter aangesloten op breadboard;
Stroom voor de ontvanger aangesloten op breadboard;
Stroom voor de UNO via USB-kabel naar PC ( bij opladen code)
Puls van kanaal 8 van de ontvanger ( 8 pots op de zender) naar pin 2;
GND van UNO naar - op breadboard;
GND van PCA9865 naar - op breadboard;
SCL op PCA9865 naar pin A5 op UNO;
SDA op PCA9865 naar pin A4 op UNO;
VCC op PCA9865 naar 5V op UNO;
+ op terminal van PCA9865 naar + op breadboard;
- op terminal van PCA9865 naar - op breadboard;
8 servo's aangesloten op kanaal 0 tot en met 7 van de PCA9865.

Resultaat: de servo's gaan om beurt, beginnend bij deze aangesloten op terminal 0 op de PCA9865, en mooi in volgorde van aansluiting, eerst helemaal naar links, en dan helemaal naar rechts.
Na de 8e servo begint weer de 1e

Hierna heb ik de USB-kabel verwijderd en de 9V accu aan de UNO aangesloten, resultaat: idem, geen storing, vlotte beweging, snelheid van de beweging zou iets lager mogen.

Bij de 2 voorgaande tests heb ik 4 blauwe miniservo's aangesloten, en 4 zwarte microservo's.
Beiden reageren gelijkaardig, waarbij de blauwe servo's een iets grotere uitslag hebben.
De blauwe servo's zouden nog iets meer uitslag mogen hebben (nu ongeveer 240°).
De zwarte servo's voor het heffen en dalen voor de lopen mogen een kleinere uitslag hebben (nu ongeveer 160°).
Bij een test deze namiddag met de voorgaande code en 4 van die zwarte microservo's werd ik bijna depressief: niet stabiel te krijgen, maar met de PCA9865 en de code uit post 126, draaien ze rustig hun rondjes mee.
Terwijl ik deze novelle aan het typen ben staan ze gans de tijd hun ding te doen, dus tot nu toe is het feilloos.
Hopelijk blijft het zo als je het uitgelezen signaal integreert.

En voor de volledigheid, heb ik nu een externe travelextender tussen poort 0 van de PCA9865 en de 1e servo aangesloten, en nog steeds blijft het stabiel, en servo 1 haalt nu nagenoeg de beoogde reisweg.

 

de 9V toch wel via de plug (= via de spanningsregelaar) mag ik hopen? Sorry, maar ik wil zeker weten dat dat niet de oorzaak van de feestbewegingen is....

dat doet geen kwaad, maar is verder ook niet nodig omdat de code uit #126 daar geen gebruik van maakt, maar autonoom een oscillerend signaal genereert.

dat wordt waarschijnlijk identiek aan de snelheid van de "echte" code, moeten we mee experimenteren.

Een extender zou toch niet meer nodig moeten zijn, als de servo het bereik van de aangeboden pulsen verwerken kan zonder vast te lopen zou dit met de PCA9865 gerealiseerd moeten kunnen worden met de waardes van USMIN en USMAX, ook weer gelijkwaardig aan de Xpulselow en Xpulsehigh arrays in de eerdere code.

De eerste stap lijkt mij een wijziging van code #126 zodat alle servo's gelijktijdig bewegen, om te zien of dat toch weer voor instabiliteit zorgt.

 

Probeer deze eens:

Code:

/***************************************************
  This is an example for our Adafruit 16-channel PWM & Servo driver
  Servo test - this will drive 8 servos, one after the other on the
  first 8 pins of the PCA9685
 ****************************************************/

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

#define USMIN  600 // This is the rounded 'minimum' microsecond length
#define USMAX  2400 // This is the rounded 'maximum' microsecond length

// servo # counter
uint8_t servonum = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("8 channel Servo test!");

  pwm.begin();

  pwm.setOscillatorFrequency(27000000); // tune any output to 50Hz using oscilloscope to get precise microseconds
  pwm.setPWMFreq(50);  // Analog servos run at ~50 Hz updates

  delay(10);
}


void loop() {
  Serial.println(servonum);
 
  // Drive each servo one at a time using writeMicroseconds(), it's not precise due to calculation rounding!
  // The writeMicroseconds() function is used to mimic the Arduino Servo library writeMicroseconds() behavior.
  for (uint16_t microsec = USMIN; microsec < USMAX; microsec++) {
    for (servonum = 0; servonum <8; servonum++) {
      pwm.writeMicroseconds(servonum, microsec);
    }
  }

  delay(500);
  for (uint16_t microsec = USMAX; microsec > USMIN; microsec--) {
    for (servonum = 0; servonum <8; servonum++) {
      pwm.writeMicroseconds(servonum, microsec);
    }
  }

  delay(500);

//  servonum++;
//  if (servonum > 7) servonum = 0; // Testing the first 8 servo channels
}

 

foutje in de code hersteld

 

inderdaad

Alle servo's bewegen tegelijk van links naar rechts naar links en naar rechts....
De beweging is bij allen gelijk, maar licht schokkerig en soms met een paar opeenvolgende grote schokken.
Link naar de video: die 2 Y-kabels rechts van de servo's zijn er alleen maar omdat de kabeltjes te kort waren, verder hebben ze geen doel.

 

Afgezien van de schokken, is de bewegingssnelheid ongeveer gelijk aan de vorige keer, toen ze één voor één draaiden?

 

Ik heb het niet gemeten, maar het is gelijkaardig, op de paar grotere schokken na.

 

Ik denk dat de stabiliteit van de voedingsbron het probleem blijft, als je meerdere servo's op hetzelfde moment start kan de spanning een dip hebben, die dan weer de signaaloverdracht stoort.
Je zou kunnen proberen om een 6V loodaccu als voeding voor de servo's te gebruiken als je die hebt, niet direct na een laadcyclus, want dan kan de spanning te hoog zijn voor servo's die maar tot 6V mogen.

Een andere mogelijkheid is om de start van opeenvolgende servo's iets te vertragen door de pulsen over de 20 ms herhaalperiode te verdelen. Ik zie daar wel kans toe met de "andere" methode die de library biedt, met pwm.setPWM().

Daarvoor begin ik maar weer met de code waarbij de servo's één voor één draaien, als dat goed gaat zal ik bovenstaande implementeren. Ik stuur nu maar 4 servo's aan.

Code:

/***************************************************
  This is an example for our Adafruit 16-channel PWM & Servo driver
  Servo test - this will drive 4 servos, one after the other on the
  first 4 pins of the PCA9685
 ****************************************************/

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

// PWM frame runs from 0 to 4095 (12 bits)

#define SERVOMIN  115
// This is the 'minimum' pulse length count (out of 4096, assuming start at 0), = 561 micros @ 50Hz

#define SERVOMAX  389
// This is the 'maximum' pulse length count (out of 4096, assuming start at 0), = 2402 micros @ 50Hz

// 205 = 1000 micros @ 50Hz  (frame = 20000 micros, 20000/1000*4096 = 205)
// 410 = 2000 micros @ 50Hz

// servo # counter
uint8_t servonum = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("4 channel Servo test!");

  pwm.begin();

  pwm.setOscillatorFrequency(27000000);
  pwm.setPWMFreq(50); // 50Hz, frame length 20 millis

  delay(10);
}

void loop() {
 
  // Drive each servo one at a time using setPWM()
  Serial.println(servonum);
  for (uint16_t pulselen = SERVOMIN; pulselen < SERVOMAX; pulselen++) {
    pwm.setPWM(servonum, 0, pulselen); // LOW>HIGH at 0, HIGH>LOW at pulselen
  }

  delay(500);
  for (uint16_t pulselen = SERVOMAX; pulselen > SERVOMIN; pulselen--) {
    pwm.setPWM(servonum, 0, pulselen);
  }

  delay(500);

  servonum++;
  if (servonum > 3) servonum = 0; // Testing the first 4 servo channels
}

 

Ik heb de code aangepast met verklarende tekst, verder geen wijziging in de werking.

 

Hoi Max,

In meerdere maten en gewichten
Een filmpje zegt meer dan 1000 woorden.

 

Nèt iets te snel denk ik , en ik denk ook te weten waarom.
Volgend stap, alle servo's tegelijk, maar nog niet met verschoven pulsen, m.a.w. ze starten allemaal op hetzelfde tijdstip. Houd die 6V accu er in!

Code:

/***************************************************
  This is an example for our Adafruit 16-channel PWM & Servo driver
  Servo test - this will drive 4 servos, all together on the
  first 4 pins of the PCA9685
 ****************************************************/

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

// PWM frame runs from 0 to 4095 (12 bits)

#define SERVOMIN  115
// This is the 'minimum' pulse length count (out of 4096, assuming start at 0), = 561 micros @ 50Hz

#define SERVOMAX  389
// This is the 'maximum' pulse length count (out of 4096, assuming start at 0), = 2402 micros @ 50Hz

// 205 = 1000 micros @ 50Hz  (frame = 20000 micros, 20000/1000*4096 = 205)
// 410 = 2000 micros @ 50Hz

// servo # counter
uint8_t servonum = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("4 channel Servo test!");

  pwm.begin();

  pwm.setOscillatorFrequency(27000000);
  pwm.setPWMFreq(50); // 50Hz, frame length 20 millis

  delay(10);
}

void loop() {
 
  // Drive each servo one at a time using setPWM()
  Serial.println(servonum);
  for (uint16_t pulselen = SERVOMIN; pulselen < SERVOMAX; pulselen++) {
    for (servonum = 0; servonum < 4; servonum++){
      pwm.setPWM(servonum, 0, pulselen); // LOW>HIGH at 0, HIGH>LOW at pulselen
    }
  }

  delay(500);
  for (uint16_t pulselen = SERVOMAX; pulselen > SERVOMIN; pulselen--) {
    for (servonum = 0; servonum < 4; servonum++){
      pwm.setPWM(servonum, 0, pulselen); // LOW>HIGH at 0, HIGH>LOW at pulselen
    }
  }

  delay(500);

//  servonum++;
//  if (servonum > 3) servonum = 0; // Testing the first 4 servo channels
}

 

https://youtube.com/shorts/WrgHwkaFj5E?

 

Ziet er goed uit, toch? De snelheid is duidelijk veel te hoog, maar eigenlijk wel wat ik met deze code verwacht had. De "for" loop verandert de puls wel in stappen, maar doet dat zó snel dat de servo gewoon op maximum snelheid (denk ik) moet draaien om dat bij te houden. Dat zal wel goed komen als ik e.e.a. in de oorspronkelijke code verwerk, dan gaan die stappen in de cadans van de pulsen die van de ontvanger komen. Ik verander SERVOMIN en SERVOMAX dan weer in Xpulselow en Xpulsehigh, dan kun je daarmee experimenteren om de uiterste draaihoeken te bepalen.