Braccio robotico servomotori impazziscono

Ciao a tutti, prima di tutto mi scuso se per caso questo thread risulta essere il doppione di una mia risposta ad un altro thread, ma non riesco più a visualizzare la mia risposta e oltretutto affianco al topic vedo la figura di un lucchetto e magari vuol dire che era stato chiuso.. Il forum ha cambiato un po' facciata e mi ritrovo un po' confusa :sweat_smile:
Ho un problema con un braccio robotico mosso da tre servomotori. I tre servomotori sono alimentati da un alimentatore separato, 5v 10A, e sono pilotati tramite apposito pin da arduino, che ha il gnd in comune con l'alimentatore.
Appena lo sketch parte (quindi appena si da l'alimentazione ai servo, oppure appena si accende l'arduino, o al reset), i servo impazziscono e per un minuto il braccio robotico si muove a caso come posseduto. Dopo si calma e fa (circa) quel che deve fare, se non che alle volte parte un nuovo movimento erroneo che dura meno di quello iniziale e poi continua a fare quel che deve. Quando è fermo in attesa del comando, qualcuno dei servo "ronza" (non ho individuato bene quale, ma secondo me non tutti, o per lo meno qualcuno ronza più degli altri).
I servo sono collegati direttamente all'alimentazione, senza che di mezzo ci siano diodi/condensatori/resistenze o varie.
Per completare posto lo sketch

#include <Servo.h> // include la Libreria Servo.h
 
Servo myservo1;  // crea l’oggetto di tipo Servo, myservo sarà l’oggetto su cui opererai
 Servo myservo2;
 Servo myservo3;              
 
int pos1 = 135;    // inizializza una variabile di tipo intero pos il cui valore sarà la posizione da impartire al servo
 int pos2 = 0;
 int pos3 = 50;
int  val = 0;  
//////////////////////////


 // NeoPixel Ring simple sketch (c) 2013 Shae Erisson
// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1
#define PIN            3

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS      12
#define BUTTON 13  
// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest
// example for more information on possible values.
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

int delayval = 100; // delay for half a second

void setup()
{
  pinMode(BUTTON, INPUT);
myservo1.attach(6);  //ORIZZONTALE 0 A 170
myservo2.attach(9);  //VERTICALE DA 0 A 120
myservo3.attach(11); //PINZA 0 A 50
  Serial.begin(9600);
  delay(5000);
  myservo1.write(135);
  delay(2000);
  myservo2.write(0);
  delay(2000);
  myservo3.write(50);
  delay(2000);

///////////////////////////////

   // This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
#if defined (__AVR_ATtiny85__)
  if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
#endif
  // End of trinket special code

  pixels.begin(); // This initializes the NeoPixel library.
}
 
 
 
void loop()
{ /*
 myservo1.write(0);
  delay(2000);
 myservo2.write(0);
   delay(2000);
 myservo3.write(0);
   delay(2000);
    myservo3.write(50);
    delay(2000);
    myservo2.write(50);
    delay(2000);
    myservo1.write(50);
    delay(2000);*/
     Serial.println("ciao");    
  val = digitalRead(BUTTON);
 if (val == HIGH) {
    for(pos1 = 135; pos1 < 170; pos1 += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo1.write(pos1);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos1);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
    delay(50);  
 }
 delay(500);

  for(pos3 =50; pos3>=0; pos3-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos3);                  
    myservo3.write(pos3);              
      delay(50);                        
  }
delay(500);


 for(pos2 = 0; pos2 < 88; pos2 += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo2.write(pos2);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos2);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
      delay(50);    
 }
delay(500);


for(pos3 = 0; pos3 < 28; pos3 += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo3.write(pos3);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos3);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
       delay(50);  
 }
 delay(500);

 for(pos2 = 88; pos2>=30; pos2-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos2);                  
    myservo2.write(pos2);              
     delay(50);                    
  }

delay(500);

      for(pos1 = 170; pos1>=135; pos1-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos1);                  
    myservo1.write(pos1);              
     delay(50);                          
  }

delay(500);

 for(pos2 = 30; pos2 < 62; pos2 += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo2.write(pos2);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos2);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
    delay(50);  
 }
for(int i=0;i<NUMPIXELS;i++){

    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
    pixels.setPixelColor(i, pixels.Color(0,0,255)); // Moderately bright green color.

    pixels.show(); // This sends the updated pixel color to the hardware.

    delay(delayval); // Delay for a period of time (in milliseconds).


   
  }

  for(int i=0;i<NUMPIXELS;i++){

    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
    pixels.setPixelColor(i, pixels.Color(0,255,0)); // Moderately bright green color.

    pixels.show(); // This sends the updated pixel color to the hardware.

    delay(delayval); // Delay for a period of time (in milliseconds).


}
  for(int i=0;i<NUMPIXELS;i++){

    // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
    pixels.setPixelColor(i, pixels.Color(255,0,0)); // Moderately bright green color.

    pixels.show(); // This sends the updated pixel color to the hardware.

    delay(delayval); // Delay for a period of time (in milliseconds).

}
 delay(1000);
 
 for(pos2 = 62; pos2>=30; pos2-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos2);                  
    myservo2.write(pos2);              
   delay(50);                      
  }

delay(500);

         for(pos1 = 135; pos1>=40; pos1-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos1);                  
    myservo1.write(pos1);              
     delay(50);                        
  }

delay(500);

for(pos2 = 30; pos2 < 85; pos2 += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo2.write(pos2);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos2);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
     delay(50);  
 }
delay(500);

 for(pos3 = 28; pos3>=0; pos3-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos3);                  
    myservo3.write(pos3);              
     delay(50);                        
  }

delay(500);

  for(pos2 = 85; pos2>=0; pos2-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos2);                  
    myservo2.write(pos2);              
    delay(50);                      
  }

delay(500);

 for(pos1 = 40; pos1 < 135; pos1 += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo1.write(pos1);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos1);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
   delay(50);  
 }
delay(500);

for(pos3 = 0; pos3 < 50; pos3 += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo3.write(pos3);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos3);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
      delay(50);  
 }
delay(500);
     /*

for(pos1 = 0; pos1 < 170; pos1 += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo1.write(pos1);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos1);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
    delay(100);  
 }
 delay(5000);
 for(pos1 = 170; pos1>=0; pos1-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos1);                  
    myservo1.write(pos1);              
    delay(100);                        
  }

 delay(5000);

 for(pos2 = 0; pos2 < 120; pos2 += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo2.write(pos2);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos2);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
    delay(100);  
 }
 delay(5000);
 for(pos2 = 120; pos2>=0; pos2-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos2);                  
    myservo2.write(pos2);              
    delay(100);                        
  }

 delay(5000);

for(pos3 = 0; pos3 < 50; pos3 += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo3.write(pos3);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos3);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
    delay(100);  
 }
 delay(5000);
 for(pos3 = 50; pos3>=0; pos3-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos3);                  
    myservo3.write(pos3);              
    delay(100);                        
  }

 delay(5000);
*/






  /*for(pos = 0; pos < 180; pos += 1)  // imposta un ciclo con valori che vanno da 0 a 180, sarano i gradi di spostamento del nostro servo
  {                                  
    myservo.write(pos);              // con il metodo write() passi all’oggetto myservo la posizione che deve raggiungere,
         Serial.println(pos);                           // il servo si sposterà gradualmente dalla sua posizione 0° alla posizione 180°
    delay(100);                       // imposta un ritardo di 15 millesimi di secondo per ogni ciclo del for.
                                     // Più sarà alto il ritardo più il servo sarà lento.
  }
  for(pos = 180; pos>=0; pos-=1)     // In questo caso imposta un ciclo con valori che vanno da 180 a 0
  {    
                    Serial.println(pos);                  
    myservo.write(pos);              
    delay(100);                        
  } */
   }
   delay(5000);
}

Inizia con mettere una resistenza di pull-down sul pulsante per non avere falsi contatti.

Ciao Paolo, il pin del pulsante a riposo è già collegato a gnd tramite una resistenza, inoltre prima il pulsante non c'era ma il problema avveniva ugualmente :pensive:

  1. usa CTRL+T nell'IDE che indenta un po meglio quel codice (perchè poi ci posti tutto quel codice commentato ?????? )

  2. Sai che i delay() sono quasi bloccanti ? Durante un delay se premi il tasto, arduino non lo può sentire. Alla fine della loop() hai un delay(5000) !

  3. quando accendi viene eseguita la setup(), io fossi in te prima cosa farei:

void setup()
{ Serial.begin(9600);
  Serial.println("avvio...");
  delay(5000);
  Serial.println("setting...");
  pinMode(BUTTON, INPUT);
  myservo1.attach(6);  //ORIZZONTALE 0 A 170
  myservo2.attach(9);  //VERTICALE DA 0 A 120
  myservo3.attach(11); //PINZA 0 A 50
  myservo1.write(135);
  delay(2000);
  myservo2.write(0);
  delay(2000);
  myservo3.write(50);
  delay(2000);    ...

Ovvero prima abilito seriale e scrivo avvio, poi dopo 5 sec setting e vedo da serial monitor quando ci sono quei msg cosa fanno i servo

  1. proverei a togliere i neopixel (come codice/libreria)

Ciao :slight_smile:
Ho fatto varie prove coi servo, ovvero ne ho provato solo uno con uno sketch semplicissimo, che dovrebbe far muovere il servo qualora il pulsante venga premuto.
Ho provato, singolarmente, tutti e tre i servo, ma tutti danno lo stesso problema: appena viene resettato l'arduino, o attaccata l'alimentazione, il servo ha un piccolo sussulto.

Poi dopo, appena viene premuto il pulsante che lo aziona, lui riceve il comando giusto (lo vedo perchè viene stampato sulla seriale) però, prima di eseguirlo per bene, oscilla rapidamente avanti e indietro. Dopo si riprende.
Dopo di che, funziona abbastanza regolarmente: premo il pulsante e lui esegue normalmente. Se lo resetto, punto e a capo: sussulto, e alla prima pressione del pulsante fa avanti e indietro.

Ho provato a cambiare arduino, a cambiare alimentatore, a togliere il pulsante... niente, non cambia nulla. Tutti e tre i servo hanno lo stesso comportamento.

I servo sono MG996R.

Aumentando il numero dei servo, aumenta la portata del problema: con tre servo in contemporanea, il braccio robotico impazzisce per svariati secondi e, anche dopo la prima volta, ogni tanto spara qualche movimento inconsulto.

Qualche soluzione? :pensive: :pensive: :pensive:

Premetto che di servo e di laser non so nulla.

Però vedo che hai (avete) 3 problemi su 3 aspetti diversi presumo di un unico grande progetto. Mi pare di capire che siete un team, probabilmente eterogeneo e non ancora ferratissimo.
Se posso... questo progetto lo fate per passione? lavoro? perché vi pagano? per qualche altro motivo?

Visti i problemi che avete e vista la strada che avete preso (almeno riguardo la gestione luci / pulsanti / seriali della mega) temo sarà un percoso molto in salita...
Forse una schiarita di idee, un brainstorming fatto con calma, una revisione totale del progetto potrebbero aiutarvi...

Io proverei un solo servo, con sketch semplice come hai già fatto MA usando alimentazione separata da 6V (anche solo un pacco di 6 pile AA cariche, controlla con tester siano 6V) (GND in comune)

Poi, hai un link ai servo che hai comprato ? MG996R non vuol dire nulla... se cerco su internet vengono fuori tante di quelle cinesate...

Ciao fratt, è così, abbiamo in progetto di aprire una escape room (progetto già fatto, soldi già spesi, affitto già in corso) per cui dobbiamo anche sbrigarci alla svelta..
Sull'arduino siamo capaci di fare le cose base, e queste di fatto son cose base, ma messe tutte insieme.. solo che ultimamente non so, sembra esserci una maledizione, per cui cose che andavano improvvisamente non vanno più... Il braccio robotico è una di queste.. e cadono le braccia, perchè far funzionare dei servo non può dare così tanti problemi, senza che si trovi nessuna spiegazione poi..
Abbiamo un ragazzo che per lavoro si occupa di cablaggi e montature di macchine industriali ma anche lui non ne ha idea e così scrivo qui sperando che magari qualcuno abbia avuto problemi simili o abbia un'illuminazione..
Per la verità abbiamo già rinunciato a tanti progetti perchè abbiamo visto che erano complessi e richiedevano troppo tempo, ma ora siamo "all'osso" e insomma dobbiamo saltarci fuori in qualche modo almeno per queste cose..
Il braccio in realtà è una di quelle cose che, se non si trova il motivo per cui i servo non funzionano, andrà tolto, ma le altre due cose per cui ho chiesto aiuto qui dovranno assolutamente trovare una soluzione..

Inoltre mi viene il nervoso perchè dico, ma cavolo, a tutti funziona, non c'è niente di complesso, perchè a noi deve dare problemi? e quindi mi incaponisco per saltarci fuori :sweat_smile:

L'alimentazione separata c'è già, solo che è da 5 volt (ma i servo dovrebbero andare anche da 4.8 volt)..
I servo sono questi
https://it.aliexpress.com/item/33027949751.html?spm=a2g0o.productlist.0.0.5d6354e9MASbXP&algo_pvid=b22b3bd6-701f-4e48-91cc-144fe40b2088&algo_expid=b22b3bd6-701f-4e48-91cc-144fe40b2088-3&btsid=0b0a050116191074898022917e99c7&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_

Lo sò che sono dati dai 4.8V ai 7.2V, ma prova ad aumentare i volt.
P.S. per quel prezzo mi paiono proprio servo cinesi. Non vorrei fossero di qualità scarsa.

Di sicuro sono cinesi purtroppo..
Alimentatore o pile da 6v non l'abbiamo, però ce le procuriamo.. Nel frattempo rischio di rompere tutto se gli do 12 volt con delle resistenze?

Evita.

Hai provato il codice di nid69ita al post #4?

Quello che segue è l'esempio dato dalla libreria per UN servo. Ho aggiunto le istruzioni per TRE servo

/* Sweep
 by BARRAGAN <http://barraganstudio.com>
 This example code is in the public domain.

 modified 8 Nov 2013
 by Scott Fitzgerald
 http://www.arduino.cc/en/Tutorial/Sweep
*/

#include <Servo.h>

Servo myservo1;  // create servo object to control a servo
Servo myservo2;  // create servo object to control a servo
Servo myservo3;  // create servo object to control a servo
// twelve servo objects can be created on most boards

int pos1 = 0;    // variable to store the servo position
int pos2 = 0;    // variable to store the servo position
int pos3 = 0;    // variable to store the servo position

void setup() {
  myservo1.attach(9);   // attaches the servo on pin 9 to the servo object
  myservo2.attach(10);  // attaches the servo on pin 10 to the servo object
  myservo3.attach(11);  // attaches the servo on pin 11 to the servo object
  myservo1.write(0);    // POSIZIONA SERVO1 A 0 GRADI
  myservo2.write(0);    // POSIZIONA SERVO2 A 0 GRADI
  myservo3.write(0);    // POSIZIONA SERVO3 A 0 GRADI

//Blocca qui il programma per controllare che i tre servo siano posizionati a 0 gradi.
//Se non lo sono inutile andare avanti.
  while (true) ;    //COMMENTA O TOGLI QUESTA RIGA PER PROCEDERE

}

void loop() {
  for (pos1 = 0; pos1 <= 170; pos1 += 1) { // goes from 0 degrees to 170 degrees
    // in steps of 1 degree
    myservo1.write(pos1);              // tell servo to go to position in variable 'pos1'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  for (pos1 = 170; pos1 >= 0; pos1 -= 1) { // goes from 170 degrees to 0 degrees
    myservo1.write(pos1);              // tell servo to go to position in variable 'pos1'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  for (pos2 = 0; pos2 <= 120; pos2 += 1) { // goes from 0 degrees to 120 degrees
    // in steps of 1 degree
    myservo2.write(pos2);              // tell servo to go to position in variable 'pos2'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  for (pos2 = 120; pos2 >= 0; pos2 -= 1) { // goes from 120 degrees to 0 degrees
    myservo2.write(pos2);              // tell servo to go to position in variable 'pos2'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  for (pos3 = 0; pos3 <= 50; pos3 += 1) { // goes from 0 degrees to 50 degrees
    // in steps of 1 degree
    myservo3.write(pos3);              // tell servo to go to position in variable 'pos3'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  for (pos3 = 50; pos3 >= 0; pos3 -= 1) { // goes from 120 degrees to 0 degrees
    myservo3.write(pos3);              // tell servo to go to position in variable 'pos3'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  delay(2000);
}

All'avvio di Arduino è normale che i servo abbiano uno scatto random, ma subito dopo si devono posizionare nelle corrispondenti posizioni di 0 gradi.
Il codice si blocca alla fine del setup() per permettere di controllare questa situazione.
Se i servo 'fanno i matti' i problemi stanno nell'hardware e allora occorre eseguire una serie di prove.
Un esempio:

  • USANDO SEMPRE IL CODICE SOPRA alimentare il/i servo dall'alimentatore a 5V E ANCHE l'Arduino dal pin 5V. Mettere le GND in comune
  • Attaccare UN SOLO servo per volta e verificare se si posiziona a 0 gradi E STA FERMO LÌ. Se questo NON accade il problema sta nell'alimentazione.
  • Connettere il servo1 INSIEME al servo2 e verificare che stiano fermi. Poi servo2 e servo3, Poi servo1 e servo3. Poi tutti e tre.

Da quello che hai detto non dovresti essere arrivato a questo punto. Dovrebbe essere successo prima qualcosa. Dimmi cosa.

Ciao,
P.

Solitamente non bado a studenti, ma Aurelias, pur essendo una studentessa almeno non è studentessa in materie tecniche.
quindi "Solo per stasera, alle ore 20, i favolosi Blues Brothers! Alla Sala Grande del Palace Hotel! Lago Wazzapamani! Alle ore 20, i favolosi Blues Brothers Show Band and Review!"

Ops scusate una vecchia registrazione, il bullone di arresto ha mandato in corto circuito il sistema di registrazione. Dice che se lei togliesse il bullone forse potrebbe farci risentire tutta la registrazione.

Ebbasta con queste registrazioni mischiate, temo di avere un qualche "dangling pointer" in testa, scusatemi domani porto quell'unità C1 ad Anchorhead e gli faccio cancellare la memoria. Così sarà finita.

tornando invece ai "nostri" di robot....
soltanto stasera baderò a un(a) studente(ssa)

I servo non sono adatti a fare bracci robotici minimamente seri
non sono adatti per nulla
anzi: non per nulla, ma per tante, tante, ragioni

  1. non sono reazionati, non esiste un anello di posizione, quindi la posizione raggiunta è solo aleatoria

  2. da spenti sono frenati dalla sola loro meccanica, quindi non è escluso che con assi pesanti da spenti il braccio si afflosci, e senza un anello di posizione arduino non sa in che posizione si trovano, quindi il primo azionamento è sempre "ondivago"

  3. da accesi ma non comandati si spostano (per la verità non tutti i modelli) all'angolo zero, e se il braccio è stato spento (o l'arduino resettato) in ingombro, vanno a sbattere

  4. quando l'oggetto servo (istanza della classe servo descritta dalla libreria servo.h) viene inizializzato, la libreria lo comanda al suo default (suo della libreria) che basta andare a vedere i sorgenti della stessa per scoprire che il default è 92,7 gradi (perché 92,7? non ne ho la più pallida idea)
    quindi dopo aver dato corrente i servo partono da una posizione sconosciuta (ma a braccio probabilmente accasciato) verso probabilmente l'angolo 0
    e, dopo l'inizializzazione di arduino essi certamente vanno all'angolo 92,7, probabilmente andando a sbattere in tutti e due i casi

  5. inoltre è risaputo che i servo economici disturbano molto (in senso di disturbi elettrici) e siccome a loro volta non sono ben protetti dai disturbi spesso (magari sempre) usare più di un servo, di scarso pregio e con cablaggi "alla carlona", porta grosse grane.

tutto questo era facilmente "scopribile" con poche ricerche
in particolare l'angolo di servo.attach() lo avevo segnalato l'anno scorso

ora.... io non credo che mi fiderei di una "escape room" realizzata con questo (scarso) studio preliminare

1 Like

Ok prima di tutto grazie perché mi pare che questa tua "discesa" per spiegare a umile plebe sia una concessione rara e mi hai dato info importanti...

Una cosa non mi torna: io ero convinta che i servomotori, per definizione, abbiano un sistema di retroazione "a feedback".. mi pare di leggerlo anche qui (ho preso la prima cosa a caso che ho trovato dove lo dice, mi sono fermata alle prime righe) Servomotore Elettrico - Servotecnica

Poi, non so cosa sia l'anello che dici tu.. però il resto che hai detto torna: ho notato anche io che il sussulto iniziale corrisponde alla inizializzazione dei servo ed è già ottimo avere capito perché.. Scusami tanto ma non posso fare ricerche di biblioteca per ogni cosa, avevo cercato su Google cosa facesse il comando Attach e mi sono limitata a constatare che sulla reference non c'era niente (di solito consigliate di guardare li, per cui mi sono accontentata)..

e probabilmente i servo, come dici, fanno interferenze tra di loro..

però allora non mi spiego perché i bracci robotici sono venduti con quei servo, la gente li compra e dá anche valutazioni alte al prodotto.. in giro è pieno di video e tutorial di braccia robotiche che funzionano con i servo senza fare una piega.. attaccate all'arduino senza nessun circuito di base... Perché, se i servo danno tutti questi problemi?

Inoltre: allora con cosa lo dovrei pilotare il braccio robotico?
A noi non serve che sia solido, professionale, ecc.. è dietro un vetro, nessuno lo tocca e deve fare tre semplicissimi movimenti!

Inoltre all'ultima frase ti rispondo così: stiamo facendo questa escape room senza troppe pretese, ci basta che le cose funzionino e superino i nostri test, l'abbiamo progettata con cose che ritenevamo nelle nostre corde (un progetto di braccio robotico, con gli stessi servo, era già stato fatto e funzionava, solo che erano controllati da levette) e abbiamo tolto ciò che abbiamo visto richiedeva troppo tempo e sforzo o competenze.. il braccio robotico qui è una delle cose più sacrificabili (ripeto deve solo fare una scenetta) per cui, tra tutto il lavoro da fare, non è assolutamente la prima cosa su cui decidere di impiegare tempo per studiarlo.. ho molta fiducia nelle cose che stiamo facendo, quando le cose non funzionano o le togliamo o le studiamo, non lasciamo niente "a caso" quindi il tuo commento lo trovo pregiudicante

No, qui ci sono solo amici che si danno una mano. Niente plebe.

Quel servo che usi ha al suo interno un motore demoltiplicato e un potenziometro calettato sullo stesso alberino mosso dal motore. La resistenza del potenziometro è il 'feedback' che serve per conoscere la posizione dell'alberino del servo. Al servo arrivano tre fili: alimentazione, ground e 'comando'. Se non ricordo male sul filo 'comando' arriva un impulso ogni 20 ms. La lrghezza dell'impulso può variare da un minimo di (mi pare) 1 ms a un massimo di (sempre mi pare) 3 ms. Comunque certamente fra 1,5 e 2,5 ms. Fra queste due ampiezze (MIN e MAX) sono compresi i 180° della rotazione dell'alberino. Fai conto 0° = 1,5 ms, 180° = 2,5 ms (o forse il contrario, ma ha poca importanza).

Tutto questo pippone per farti capire che qualunque disturbo elettromagnetico sul filo 'comando' è in grado di far 'impazzire' il servo. Gli alimentatori switching, come probabilmente quello che usi tu, hanno una uscita 'sporca' dovuta ai residui della frequenza di switching utilizzata. Ovviamente migliore è la qualità dell'alimentatore minore è lo 'sporco' dell'uscita. Maggiore è la corrente richiesta, maggiore è lo sporco. Inoltre l'improvvisa richiesta di corrente (come quella dovuta all'avvio del motore di un servo) può provocare variazioni repentine brevissime dell'alimentazione (sempre in funzione della qualità dell'alimentatore) che possono irradiare in giro disturbi elettromagnetici.

Tutto quest'altro pippone spiega perché, se si nota un impazzimento dei servo, la prima cosa che si consiglia è: alimentazione separata dei servo tramite pacco di 4 batterie alcaline AA nuove da 1,5 V (6 V totali); alimentazione dell'Arduino da USB del computer o di altra fonte (caricabatterie per cellulare); connessione del - del pacco batterie con GND di Arduino (essenziale!); connessioni Arduino <=> servo corte (i 30 cm dei cavetti vanno bene, senza prolunghe). Se anche così i servo, comandati da un codice 'copiato' dagli esempi della libreria Servo.h, impazziscono, allora o sono difettosi i servo o è difettoso Arduino. Oppure avete bisogno di un esorcista.

Se però così i servo funzionano, allora bisogna cambiare un elemento per volta. Ad esempio: sostituire le betterie con l'alimentatore switching, oppure aggiungere un altro servo, e così via.

Inoltre non bisogna credere a tutto quello che si vede su internet. C'è anche la produzione di energia con motorini e magneti. A quando l'uso della ceralacca, fiammiferi e spilli?

Ciao,
P.

1 Like

Ciao pgiagno ti ringrazio tanto! Avevo sempre pensato fosse l'alimentatore poco di qualità (non sapevo bene però come funzionasse la cosa), avevo provato a cambiarlo con un altro e i problemi erano uguali, ma sicuramente anche l'altro non è di qualità eccelsa..
Adesso grazie a voi ho un po' una visione generale più completa :slight_smile: vedremo di fare prove con alimentazioni diverse!

Ciao ragazzi! Ho fatto varie prove e il problema si è risolto! (Non ho ancora capito come).
Ho provato prima con 4 pile da 1.5 volt: il servo nel migliore dei casi stava immobile e aveva dei micro spasmi, invece nel peggiore dei casi andava dal minimo al massimo del suo spostamento, in continuazione. Disperata, ho provato a utilizzare nuovamente l'alimentatore 5v che mi dava problemi ed alimentare un servo solo, poi due, poi tre (processo che in realtà avevo già provato nei giorni precedenti) e niente.. a questo giro non ha dato problemi! Boh mi sento presa in giro dalla tecnologia.. ultimamente mi capita molto spesso che le cose prima funzionino, poi no, poi di nuovo si.. :sweat_smile:
A dire la verità, l'unica cosa che ho cambiato è stata la ciabatta a cui ho attaccato l'alimentatore, ma in precedenza dava problemi su varie ciabatte.. va a sapere!
Comunque vi ringrazio tutti perchè mi avete spiegato un sacco di cose e alla fine seguendo le vostre indicazioni il problema pare risolto :slight_smile:

Sono contento che abbiate risolto. Mi spiace solo che non abbiate capito perché. IN una situazione come questa io non ci dormivo la notte.

Altri tempi.

Ciao,
P.

Ma con 4 pile, (spero AA e non AAA) alimentavi solo servo o anche arduino?