Motore sotto plancia per deviatoi con servocomando

[bassistax]

Quando si dice che la notte porta consiglio .... ho ricontrollato il mio software e ho visto che ,per come è scritto il codice ,quello che ho definito un bug in realtà non lo è . Supponiamo che al momento dello spegnimento io ho un deviatoio posizionato su "normale" e uno su "deviata"; alla successiva accensione,nel programma ci sono due righe di comando per portare al minimo i servo (su posmin). Il servo in posizione "normale" non si muove, viceversa quello che si trova in condizione "deviata" viene riportato alla posizione "normale". Questo avverrà alla velocità intrinseca del servo (nel mio caso circa 1 secondo),non essendoci nulla che ne regoli la velocità..... poi il programma entra in loop e tutti i seguenti movimenti sono gestiti dalle due routine che permettono lo spostamento lento (circa tre secondi).
Spero di essere riuscito a spiegarmi.
Mi sono anche letto il tuo software su GAS TT Lab.... bello e polivalente .
Visto che anche tu usi all'inizio i comandi per posizionare a 0 i servo:

// Posizionamento a 0 di tutti i servi
mioservo1.write(0);
mioservo2.write(0);
mioservo3.write(0);
mioservo4.write(0);
mioservo5.write(0);
mioservo6.write(0);

per farti capire cosa intendo dire ,puoi fare una prova con il tuo circuito per riprodurre le stesse condizioni : posiziona (durante il normale funzionamento) un servo ,ad esempio il n°3, su 30 gradi che è lo spostamento max che hai nel software. Ora spegni ,attendi qualche secondo e poi riaccendi. Il comando mioservo3.write(0) ,in fase di setup, lo riposizionerà al punto min. Dovresti riuscire a vedere che tale spostamento non sarà lento ,ma più veloce perchè il programma non è ancora entrato in controllo e il delay non agisce. Visto che io uso un'angolo di rotazione maggiore, la differenza è maggiormente apprezzabile .
Questo è quanto son riuscito a dedurre dalle mie elucubrazioni notturne. ....
Se effettui la prova fammi sapere l'esito.

[Edgardo_Rosatti]

Grazie per il tuo contributo Claudio.

Si, in realtà quello che mi hai proposto lo avevo già fatto.
Il comando mioservoX.write(numero dei gradi), se usato in modo diretto non consente di variare la velocità angolare del servo ed esso si muoverà alla massima velocità consentita. Nel loop hai i cicli for con il comando "delay" e, come dici puoi impostare un ritardo per l'azionamento lento dei servi.

L'unico modo poi per avere una memoria delle ultime posizioni del servo è quella di memorizzare gli angoli in EEPROM tramite la libreria EEPROM.h.
In questo modo possiamo recuperare la posizione dei servi lasciata prima dell'ultimo spegnimento del sistema.

In base al microcontrollore usato sulla scheda Arduino, abbiamo a disposizione un piccolo banco di memoria che conserva i suoi dati anche quando la scheda è spenta.

I reference citano:

The supported micro-controllers on the various Arduino and Genuino boards have different amounts of EEPROM: 1024 bytes on the ATmega328P, 512 bytes on the ATmega168 and ATmega8, 4 KB (4096 bytes) on the ATmega1280 and ATmega2560. The Arduino and Genuino 101 boards have an emulated EEPROM space of 1024 bytes.


https://www.arduino.cc/en/Reference/EEPROM

Ogni cella di memoria può contenere informazioni a 8 bit, quindi numeri decimali compresi tra 0 e 255. Più che sufficienti per memorizzare gli angoli dei servi.

[bassistax]

Ciao Edgardo.....ho cercato notizie sulla libreria EEPROM.H che mi hai suggerito e devo dire che a prima vista non mi sembra difficile da implementare nello sketch. Il suo uso nel mio caso, mi lascia un tantino perplesso e ti spiego perchè. Nel tuo programma fai uso di pulsanti che, dopo lo spegnimento, non producono nessun effetto. Anche se li premi erroneamente non succederà nulla.....quando accendi, leggi i valori contenuti nelle celle di memoria EEPROM e li usi per ritrovare la configurazione all'atto dello spegnimento. Fin qui non fa una grinza.... nel mio caso invece può accadere che per un "x motivo" venga spostato un selettore da una posizione all'altra e qui casca l'asino. Ripescando i dati dalla memoria avrei comunque una configurazione falsata . Devo dire che ho scelto i deviatori a levetta a due vie (sei pin) per comodità di sinottico ( oltre alla posizione della levetta posso usare una via per accendere due led che alternativamente mi indicheranno la posizione del deviatoio) e non voglio rinunciarci ....
Visto che tutto funziona egregiamente penso che rimarrò con questo hardware. In ogni caso mi sarà stato utile capire l'uso di questa libreria di Arduino e per questo non posso che ringraziarti.

Sto implementando una parte ( che ha dimensioni di circa 80x160 cm) del futuro plastico e sta comodamente anche sul tavolo della cucina....per ora questo mi consente ogni tanto di far circolare le loco per mantenerle in perfetto ordine. Ho già upgradato lo sketch per gestire i sette servo che userò in questa parte .

[Edgardo_Rosatti]

Ho capito Claudio e in effetti nel tuo caso, l'uso della libreria EEPROM.h non avrebbe senso. Sicuramente, se scrivi una routine che come prima cosa legge lo stato degli interruttori per riportare i servi all'ultima impostazione riesci a risolvere egregiamente.

Il concetto lo si può esprimere anche così; esistono due tipi di circuiti, o meglio di logiche dei circuiti:
La logica cablata e la logica programmabile.

Nella logica cablata è il collegamento tra dispositivi a determinare il funzionamento del circuito, cioè lo schema elettrico vero e proprio.
Nella logica programmabile è il programma che determina il funzionamento del circuito. Lo schema elettrico, in questo caso sarà sempre uguale ed è per questo che devono essere utilizzati i giusti componenti, o meglio, componenti che non limitino le funzioni programmabili della logica.

In questo mio progetto ho utilizzato tutte le porte di un Arduino Nano per attivare 6 servi tramite 6 coppie di tasti e contemporaneamente attivare 6 relè. Ne avanzano 2 per l'interfaccia seriale I2C che userò per collegare tra loro più schede di questo tipo. Ho già progettato anche una scheda "master" che presenterò a breve. Ma quello che conta è che con questo mio circuito è possibile creare una infinità di logiche di comando.

La libreria per sfruttare il protocollo I2C si chiama whire.h ed il suo funzionamento è spegato qui:
https://www.arduino.cc/en/Reference/Wire

I pin di Arduino che sfruttano tale protocollo sono A4 e A5 per la scheda UNO e Nano. Vedere i riferimenti sopra per le altre schede.
In particolare abbiamo la linea SDA (Serial DAta) sul pin A4 e SCL (Serial CLock) sul pin A5.
Nota: Arduino Nano, rispetto all'UNO ha 8 porte analogiche anzichè 6.

Ogni pin SDA e SCL di tutti gli Arduino collegati insieme devono fare capo a queste due lineee:

Schema a blocchi di una linea seriale I2C

Qui il wiki:
https://it.wikipedia.org/wiki/I%C2%B2C

[Edgardo_Rosatti]

Pubblico qui la foto della scheda master per il controllo della/e scheda/e dei relè vista poco sopra tramite interfaccia seriale I2C:

Scheda master I2c per servi

Lo schema elettrico della scheda è questo:

Schema elettrico Master I2C

Descrizione dello schema elettrico:

Vengono usati una scheda a microcontrollore Arduino Nano, un display LCD con caratteri bianchi e sfondo azzurro di tipo HD44780 e un tastierino a 16 tasti, "keypad".

I componenti della scheda sono una resistenza da 220 OHM (R1) per accendere il led di retroilluminazione del display LCD e un trimmer da 10KOHM (R2) per regolare il contrasto del display LCD. Una coppia di morsetti a cacciavite (4 poli) per i collegamenti esterni ed una strip pin da 8 poli per collegare il tastierino "keypad".
Il keypad è formato da 16 tasti e contiene le cifre da 0 a 9, lelettere A, B, C e D e i simoli asterisco e canelletto *, #

Display + keypad

Il software per ora legge solo i dati provenienti al "keypad" e li visualizza sul display.
Prossimamente vedremo come integrare la scheda servi e relè con questo progetto.

Software display lcd e keypad:

Codice: Seleziona tutto

// Centralina di comando per servi basata su bus I2C, Edgardo Rosatti (c) 2020

// Definizione display LCD
#include <LiquidCrystal.h>

// Definizione tastiera
#include <Keypad.h>

const byte ROWS = 4; // Quattro righe
const byte COLS = 4; // Quattro colonne

char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

// Definizione mappa della tastiera
byte rowPins[ROWS] = { 8, 9, 10, 11 }; // Riga 0,1,2,3
byte colPins[COLS] = { 13, 12, 15 ,14 }; // Colonna 0,1,2,3

// Creazione della tastiera
Keypad kpd = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

// Definizione collegamenti display
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  lcd.print("Tasto premuto:");
}

void loop()
{
  char key = kpd.getKey();
  if (key) {
    lcd.setCursor(0,1),
    lcd.print(key);
  }
}

[Nick8526]

Ciao,
nel mio plastico gestisco tutto con un Arduino mega, gli scambi sono azionati tramite bottoni (ad impulsi, normalmente aperti).
Nella giornata di domenica, ho aggiunto anche un relè per staccare l'alimentazione dopo il movimento dei servi. Ho fatto questo, perchè i servi economici che ho usato, dopo un pò di tempo, dopo la regolazione, cominciano a ronzare. Leggevo che è a causa della polvere, che sporca i potenziomentri che hanno dentro e che servono al servo per controllare la propria posizione. Interrompendo l'alimentazione non ronzano ed ho risolto in modo definitivo il problema.

Vi posto lo sketch nell'ultima versione.

Codice: Seleziona tutto

/* Firmware Pannello
 by Nick85

*/

#include <Servo.h>

// definizione led
  #define LED1 24 //1                          
  #define LED2 26 //2
  #define LED3 28 //3
  #define LED4 30 //4
  #define LED5 32 //5
  #define LED6 34 //6            
  #define LED7 36 //7
  #define LED8 38 //8
  #define LED9 40 //9
  
  #define LED1b 31 //1b
  #define LED2b 33 //2b
  #define LED3b 35 //3b          
  #define LED4b 37 //4b
  #define LED5b 39 //5b
  #define LED6b 41 //6b
  #define LED7b 43 //7b
  #define LED8b 45 //8b 
  #define LED9b 47 //8b

  #define RELAIS1 21 //280320 Definizione relais per interruzione alimentazione servi
  
//definizione bottoni           
  #define BUTTON1 14 //1  
  #define BUTTON3 15//3 
  #define BUTTON4 17//4
  #define BUTTON5 18 //5
  #define BUTTON6 19 //6
  #define BUTTON7 20 //7
  #define BUTTON8 16 //8
  #define BUTTON9 22 //9

//dichiaro i servi
Servo servo1;  
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;
Servo servo6;
Servo servo7;
Servo servo8; 
Servo servo9; 

//http://arduinotutorial.altervista.org/category/digital-io/debounce/
#define debounce 700 
long time = 0;  //Ultimo tempo in cui il pin di OUTPUT è stato attivato

int val[10] = {0,0,0,0,0,0,0,0,0,0};// si userà val per conservare lo stato del pin di input
int vecchio_val[10] = {0,0,0,0,0,0,0,0,0,0};// si userà vecchio_val per conservare lo stato del pin di input al passo precedente         
int stato [10] = {0,0,0,0,0,0,0,0,0,0};// ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso

int pos = 0;    
int maxpos = 165;            
int minpos = 15; 
int initmaxpos = 2300; //2300           
int initminpos = 700; //700
boolean StatusChanged[10] ={1,1,1,1,1,1,1,1,1,1};
boolean AStatusIsChanged = false;
int passo =1;
int sleepingTime = 10;
int LedBlinkTime = 15;

void setup() {  
  Serial.begin(9600);
  servo1.attach(2,initminpos,initmaxpos);//1
  servo2.attach(3,initminpos,initmaxpos);//2
  servo3.attach(4,initminpos,initmaxpos);//3
  servo4.attach(5,initminpos,initmaxpos);//4
  servo5.attach(6,initminpos,initmaxpos);//5
  servo6.attach(7,initminpos,initmaxpos);//6
  servo7.attach(8,initminpos,initmaxpos);//7
  servo8.attach(9,initminpos,initmaxpos);//8 
  servo9.attach(10,initminpos,initmaxpos);//9
  
  //140616 start - dichiaro i pin dei led come output
  pinMode(LED1,OUTPUT); //1              
  pinMode(LED2,OUTPUT); //2
  pinMode(LED3,OUTPUT); //3
  pinMode(LED4,OUTPUT); //4
  pinMode(LED5,OUTPUT); //5
  pinMode(LED6,OUTPUT); //6            
  pinMode(LED7,OUTPUT); //7
  pinMode(LED8,OUTPUT); //8
  pinMode(LED9,OUTPUT); //9
  pinMode(LED1b,OUTPUT); //1b
  pinMode(LED2b,OUTPUT); //2b
  pinMode(LED3b,OUTPUT); //3b          
  pinMode(LED4b,OUTPUT); //4b
  pinMode(LED5b,OUTPUT); //5b
  pinMode(LED6b,OUTPUT); //6b
  pinMode(LED7b,OUTPUT); //7b
  pinMode(LED8b,OUTPUT); //8b 
  pinMode(LED9b,OUTPUT); //9b
  //140616 end

  pinMode(RELAIS1,OUTPUT); 
}

void loop() {
 
  
  ReadButtons();
  ManageStati();
  ManageRelais();//280320
  ManageServos();
  ManageRelais();//280320
  BlinkLed(); 
}


int getToPos(int LocStato){
     
  if (LocStato == 0){
    return maxpos;
  }
  else if (LocStato == 1) {
    return minpos;
  }
}


void ReadButtons(){
  //leggo tutti i bottoni
  val[1] = digitalRead(BUTTON1);
  // 280320 bottone non più in uso val[2] = digitalRead(BUTTON2);
  val[3] = digitalRead(BUTTON3);
  val[4] = digitalRead(BUTTON4);
  val[5] = digitalRead(BUTTON5);
  val[6] = digitalRead(BUTTON6);
  val[7] = digitalRead(BUTTON7);
  val[8] = digitalRead(BUTTON8);
  val[9] = digitalRead(BUTTON9);
}


void ManageStati(){
 // controlla se è un tasto ha cambiato stato
  if ((val[1] == HIGH) && (vecchio_val[1] == LOW)&& (millis() - time > debounce)){stato[1] = 1 - stato[1]; StatusChanged[1]=true;time = millis();}  
  vecchio_val[1]=val[1]; 
  //if ((val[2] == HIGH) && (vecchio_val[2] == LOW)&& (millis() - time > debounce)){stato[2] = 1 - stato[2]; StatusChanged[2]=true;time = millis();}
  //vecchio_val[2]=val[2];
  stato[2] = stato[1]; 
  StatusChanged[2] = StatusChanged[1];
  if ((val[3] == HIGH) && (vecchio_val[3] == LOW)&& (millis() - time > debounce)){stato[3] = 1 - stato[3]; StatusChanged[3]=true;time = millis();}
  vecchio_val[3]=val[3];
  if ((val[4] == HIGH) && (vecchio_val[4] == LOW)&& (millis() - time > debounce)){stato[4] = 1 - stato[4]; StatusChanged[4]=true;time = millis();}
  vecchio_val[4]=val[4];
  if ((val[5] == HIGH) && (vecchio_val[5] == LOW)&& (millis() - time > debounce)){stato[5] = 1 - stato[5]; StatusChanged[5]=true;time = millis();}
  vecchio_val[5]=val[5];
  if ((val[6] == HIGH) && (vecchio_val[6] == LOW)&& (millis() - time > debounce)){stato[6] = 1 - stato[6]; StatusChanged[6]=true;time = millis();}
  vecchio_val[6]=val[6];
  //if ((val[7] == HIGH) && (vecchio_val[7] == LOW)&& (millis() - time > debounce)){stato[7] = 1 - stato[7]; StatusChanged[7]=true;time = millis();}
  //vecchio_val[7]=val[7];
  stato[7] = stato[6]; 
  StatusChanged[7] = StatusChanged[6];
  if ((val[8] == HIGH) && (vecchio_val[8] == LOW)&& (millis() - time > debounce)){stato[8] = 1 - stato[8]; StatusChanged[8]=true;time = millis();}
  vecchio_val[8]=val[8];
  if ((val[9] == HIGH) && (vecchio_val[9] == LOW)&& (millis() - time > debounce)){stato[9] = 1 - stato[9]; StatusChanged[9]=true;time = millis();}
  vecchio_val[9]=val[9];
}

void ManageServos(){
  if ((getToPos(stato[1]) == maxpos) && (StatusChanged[1] ==true)) { for (pos = minpos; pos <= maxpos; pos += passo) {servo1.write(pos);delay(sleepingTime);} StatusChanged[1] =false;}
  if ((getToPos(stato[1]) == minpos) && (StatusChanged[1] ==true)) { for (pos = maxpos; pos >= minpos; pos -= passo) {servo1.write(pos);delay(sleepingTime);}  StatusChanged[1] =false;}

  if ((getToPos(stato[2]) == maxpos) && (StatusChanged[2] ==true)) { for (pos = minpos; pos <= maxpos; pos += passo) {servo2.write(pos);delay(sleepingTime);} StatusChanged[2] =false;}
  if ((getToPos(stato[2]) == minpos) && (StatusChanged[2] ==true)) { for (pos = maxpos; pos >= minpos; pos -= passo) {servo2.write(pos);delay(sleepingTime);}  StatusChanged[2] =false;}

  if ((getToPos(stato[3]) == maxpos) && (StatusChanged[3] ==true)) { for (pos = minpos; pos <= maxpos; pos += passo) {servo3.write(pos);delay(sleepingTime);} StatusChanged[3] =false;}
  if ((getToPos(stato[3]) == minpos) && (StatusChanged[3] ==true)) { for (pos = maxpos; pos >= minpos; pos -= passo) {servo3.write(pos);delay(sleepingTime);}  StatusChanged[3] =false;}

  if ((getToPos(stato[4]) == maxpos) && (StatusChanged[4] ==true)) { for (pos = minpos; pos <= maxpos; pos += passo) {servo4.write(pos);delay(sleepingTime);} StatusChanged[4] =false;}
  if ((getToPos(stato[4]) == minpos) && (StatusChanged[4] ==true)) { for (pos = maxpos; pos >= minpos; pos -= passo) {servo4.write(pos);delay(sleepingTime);}  StatusChanged[4] =false;}

  if ((getToPos(stato[5]) == maxpos) && (StatusChanged[5] ==true)) { for (pos = minpos; pos <= maxpos; pos += passo) {servo5.write(pos);delay(sleepingTime);} StatusChanged[5] =false;}
  if ((getToPos(stato[5]) == minpos) && (StatusChanged[5] ==true)) { for (pos = maxpos; pos >= minpos; pos -= passo) {servo5.write(pos);delay(sleepingTime);}  StatusChanged[5] =false;}

  if ((getToPos(stato[6]) == maxpos) && (StatusChanged[6] ==true)) { for (pos = minpos; pos <= maxpos; pos += passo) {servo6.write(pos);delay(sleepingTime);} StatusChanged[6] =false;}
  if ((getToPos(stato[6]) == minpos) && (StatusChanged[6] ==true)) { for (pos = maxpos; pos >= minpos; pos -= passo) {servo6.write(pos);delay(sleepingTime);}  StatusChanged[6] =false;}

  if ((getToPos(stato[7]) == maxpos) && (StatusChanged[7] ==true)) { for (pos = minpos; pos <= maxpos; pos += passo) {servo7.write(pos);delay(sleepingTime);} StatusChanged[7] =false;}
  if ((getToPos(stato[7]) == minpos) && (StatusChanged[7] ==true)) { for (pos = maxpos; pos >= minpos; pos -= passo) {servo7.write(pos);delay(sleepingTime);}  StatusChanged[7] =false;}

  if ((getToPos(stato[8]) == maxpos) && (StatusChanged[8] ==true)) { for (pos = minpos; pos <= maxpos; pos += passo) {servo8.write(pos);delay(sleepingTime);} StatusChanged[8] =false;}
  if ((getToPos(stato[8]) == minpos) && (StatusChanged[8] ==true)) { for (pos = maxpos; pos >= minpos; pos -= passo) {servo8.write(pos);delay(sleepingTime);}  StatusChanged[8] =false;}

  if ((getToPos(stato[9]) == maxpos) && (StatusChanged[9] ==true)) { for (pos = minpos; pos <= maxpos; pos += passo) {servo9.write(pos);delay(sleepingTime);} StatusChanged[9] =false;}
  if ((getToPos(stato[9]) == minpos) && (StatusChanged[9] ==true)) { for (pos = maxpos; pos >= minpos; pos -= passo) {servo9.write(pos);delay(sleepingTime);}  StatusChanged[9] =false;}

}


void BlinkLed(){
  //Accendo i led http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay

  if (stato[1] == 0) {digitalWrite(LED1, HIGH); digitalWrite(LED1b, LOW);}
  if (stato[2] == 0) {digitalWrite(LED2, HIGH); digitalWrite(LED2b, LOW);}
  if (stato[3] == 0) {digitalWrite(LED3, HIGH); digitalWrite(LED3b, LOW);}
  if (stato[4] == 0) {digitalWrite(LED4, HIGH); digitalWrite(LED4b, LOW);}
  if (stato[5] == 0) {digitalWrite(LED5, HIGH); digitalWrite(LED5b, LOW);}
  if (stato[6] == 0) {digitalWrite(LED6, HIGH); digitalWrite(LED6b, LOW);}
  if (stato[7] == 0) {digitalWrite(LED7, HIGH); digitalWrite(LED7b, LOW);}
  if (stato[8] == 0) {digitalWrite(LED8, HIGH); digitalWrite(LED8b, LOW);}
  if (stato[9] == 0) {digitalWrite(LED9, HIGH); digitalWrite(LED9b, LOW);}
  
  if (stato[1] == 1) {digitalWrite(LED1b, HIGH); digitalWrite(LED1, LOW);}
  if (stato[2] == 1) {digitalWrite(LED2b, HIGH); digitalWrite(LED2, LOW);}
  if (stato[3] == 1) {digitalWrite(LED3b, HIGH); digitalWrite(LED3, LOW);}
  if (stato[4] == 1) {digitalWrite(LED4b, HIGH); digitalWrite(LED4, LOW);}
  if (stato[5] == 1) {digitalWrite(LED5b, HIGH); digitalWrite(LED5, LOW);}
  if (stato[6] == 1) {digitalWrite(LED6b, HIGH); digitalWrite(LED6, LOW);}
  if (stato[7] == 1) {digitalWrite(LED7b, HIGH); digitalWrite(LED7, LOW);}
  if (stato[8] == 1) {digitalWrite(LED8b, HIGH); digitalWrite(LED8, LOW);} 
  if (stato[9] == 1) {digitalWrite(LED9b, HIGH); digitalWrite(LED9, LOW);} 
  
  
delay(LedBlinkTime*8);
PrintStati();

}
void ManageRelais(){
  //280320 creata funzione per gestione relais    
  AStatusIsChanged=false;
  digitalWrite(RELAIS1, LOW);
  Serial.print("Attivazione relais  -  ");
  Serial.println(AStatusIsChanged);
  for (int i = 1; i <= 9; i++) {if (StatusChanged[i] == true) {AStatusIsChanged=true;}}  
  if (AStatusIsChanged == true) {digitalWrite(RELAIS1, HIGH);}
  Serial.print("Disattivazione relais  -  ");
  Serial.println(AStatusIsChanged);
}

void PrintStati(){
  Serial.print("Versione firmware 280320  -  ");
  Serial.print(stato[1]);
  Serial.print(stato[2]);
  Serial.print(stato[3]);
  Serial.print(stato[4]);
  Serial.print(stato[5]);
  Serial.print(stato[6]);
  Serial.print(stato[7]);
  Serial.print(stato[8]);
  Serial.println(stato[9]);
}
  

[Nick8526]

qui lo schema originario del pannello, manca il relais messo domenica e sono stati abiliti un paio di bottoni in quanto due coppie di scambi lavorano in modo accoppiato, comandati da 1 solo tasto.

spero vi sia utile.

Ciao

[bassistax]

@Nick8526
Bel lavoro ,complimenti ..... A proposito , lamenti il fatto che i servo ronzano alla fine del movimento. Questo può essere anche imputabile al finecorsa meccanico reale più basso di quello impostato da te nel programma.
Mi spiego con un esempio.Nel programma hai inserito il dato di posizione max spostamento a 165 ma ipotizziamo che meccanicamente il deviatoio arrivi già a battuta a 155.Il servo cercherà comunque di raggiungere quota 165 impostata. In questo caso potranno verificarsi due casi:
1) l'asticella in acciaio armonico (che comanda il deviatoio) flette di quel tanto che basta a sistemare le cose e il servo si ferma a 165.
2) l'assorbimento dell'asticella non basta e la forza meccanica si oppone alla rotazione del servo ... in tal caso il servo continuerebbe a muoversi , ma essendo bloccato lo sentiremo ronzare. Puoi provare a diminuire il range di rotazione (magari impostando 25 e 155 ) e vedere se il difetto scompare .
Chiaramente questo è un suggerimento ipotetico a tavolino visto che non conosco fisicamente come stanno le cose.

[Nick8526]

Ciao, grazie per la dritta, in realtà l'asticella di filo armonico ha una forma fatta ad Hoc per assorbire tali imperfezioni.

Si vede male qua:


Nel video il relais non c'era ancora.

Ed ecco una foto:

Ho dato apposta un pelo di precarico in più alla molla (aumentando la posizione finale) al fine di garantire che la molla avesse una forza sufficiente a far scattare lo scambio. In caso contrario la molla contenuta in alcuni scambi Hornby non riusciva a scattare.
In questo modo ho anche la sicurezza che a seguito di tallonamento l'ago torni a posto senza necessità di manovre ulteriori.

[Edgardo_Rosatti]

Complimenti Nicola e Claudio per le vostre realizzazioni!

Nicola: vedo un porta servo di colore rosso nella foto qui sopa. Me ne potresti parlare? Lo trovo molto interessante.

Comunque, per quanto riguarda il controllo e la gestione di un servo, il ronzio, in un sistema dinamico lo si avrà sempre.
Il servo è fatto apposta per mantenere una posizione impostata dal comando impartitogli, quindi il consiglio primario è quello di usare alimentatori in grado di erogare una corrente sufficiente; cioè abbondare con il dimensionamento dell'alimentatore dei servi.

In aeromodellismo, i servi sono sempre e costantemente in movimento per via delle sollecitazioni dinamiche a cui sono sottoposti ed è normale che ronzino.

Grazie

[Nick8526]

Ciao Egidio, grazie mille, in realtà quello che vedi è merito del lavoro di un'altro.
Lo trovi qui:
http://www.thingiverse.com/thing:3645615

In origine li avevo fatti con degli angolari di alluminio, ma non mi soddisfacevano, poi ho preso la stampante 3d e così dopo molte prove ho preso questi da thingverse

[bassistax]

Mi riallaccio a questo 3d per condividere un'esperienza che per qualcuno può essere utile.
Nel mio plastico analogico in costruzione, avevo saltuariamente dei piccoli movimenti anomali dei servo durante il normale transito dei convogli. In particolar modo con il vagone appoggio motorizzato a due assi (descritto qui https://www.scalatt.it/forum/viewtopic.php?f=83&t=16666 ); non so come,ma c'erano dei disturbi . Come alimentatore per la trazione uso il circuito M.A.D.T. ( modulo accelerazione decelerazione treni) pubblicato da Trissa. Per prima cosa ho ricontrollato tutti i collegamenti di negativo a massa ..... niente. Ho aggiunto un filtro antidisturbo sulla linea a 220 volt per gli alimentatori da 12V(servizi) e 5V ( per i servo) ,niente. Ho anche considerato il fatto di poter inserire un relè di sgancio,come suggerito qualche post fa da Nick8526. Poi rovistando nelle varie scatoline dove tengo i componenti,mi è caduto l'occhio su uno scompartimento pieno di condensatori..... visto che il circuito di Trissa non ne prevedeva in uscita ,ne ho preso uno di piccolo valore in polipropilene da 0,1microfarad (non polarizzato) e l'ho piazzato ai morsetti + e - della trazione.Dato il valore piccolissimo, non influisce sul normale funzionamento del modulo,ma riesce a fugare a massa i disturbi.
Risultato : tutto sparito,niente disturbi e servo fermi come desiderato .

[Edgardo_Rosatti]

Io non capisco proprio quale sia il problema.
Se un servocomando ronza è per mantenere la sua posizione quando è sotto sforzo. Non è una questione di disturbi.

Nelle caratteristiche di un servocomando è indicata la forza massima in chilogrammi che esso riesce a mantenere proprio quando è sotto sforzo in base alla distanza che c'è tra l'astina calettata sulla squadretta ed il fulcro del servo.

I servocomandi sono nati per gestire in modo proporzionale i comandi di modelli dinamici come auto, navi, aerei ed elicotteri.
Su un aeromodello, il servo degli alettoni subisce uno sforzo notevole e sicuramente ronzerà, così come farà il servo dello sterzo di una automobile proprio perchè sono sottoposti a sollecitazioni dinamiche.

Se un servo di un motore sottoplancia ronza, è perchè spinge troppo la traversina che muove gli aghi del deviatoio.
Va solo tarata la corsa del servo; inserire condensatori o filtri antidisturbo non serve a nulla.

PS: prendete un servo e comandatelo con un tester per servi, poi provate a forzare la squadretta con le dita e osservate come si comporta.

[bassistax]

Io non capisco proprio quale sia il problema

.
Ciao Edgardo .... vediamo se riesco a spiegarlo meglio .... non si trattava di semplice ronzio di "fondo corsa"(in tal caso non mi sarei certo preoccupato),ma di movimenti bruschi in avanti o indietro di vari gradi ,che a volte muovevano in parte il deviatoio. Potevano compromettere il corretto transito del convoglio. Sembrava come se per qualche istante venissero in qualche modo influenzati gli impulsi di comando tra Arduino e i servo. La cosa strana è che il difetto si palesava solo durante la marcia ( in special modo con la composizione che ho descritto nel mio precedente post) . Visto che a loco ferme tutto funzionava perfettamente, ho pensato di agire sulla linea di trazione che evidentemente doveva essere colpevole.
Mi dirai ... "certo che capitano tutte a te e pure assurde" e che ci vuoi fare...ad ogni buon conto ho risolto a costo zero , ora mi godo il transito dei rotabili e il regolare funzionamento dei deviatoi.


P.S. Ho segnalato il problema nel caso qualcun altro avesse problemi simili (penso che questo sia il vero spirito del forum).

[Edgardo_Rosatti]

Grazie della precisazione Claudio,
no, non ti dico che capitano tutte a te
Non avevo capito bene il tuo problema.

[sintesi]

Ciao a tutti

mi riallaccio a questa discussione, condividendo l'idea di Claudio.

Avendo anche io riscontrato problemi di ronzio con i servo specie su distanze di alcuni metri dal controller, ho risolto appunto utilizzando 2 condensatori di filtro di piccolo valore, uno fra Vcc e GND l'altro fra segnale e GND nei pressi dei servo.

Premetto che gestisco i servo utilizzando una scheda PCA9685 interfacciata in I2C all'arduino, che oltre a gestire fino a 16 servo libera l'AVR dalla generazione dei segnali PWM.

Il problema del ronzio da sforzo meccanico, capita e lo taro modificando i valori di angolo inviati ai servo.

Permane irrisolto il problema di movimento veloce all'accensione del sistema.
Pare sia dovuto alla mancanza del segnale PWM al momento dell'alimentazione dei servo.
Questo punto è working in progress, ma anche in rete nessuna soluzione al momento.

grazie per consigli e migliorie

saluti

[antogar]

Ciao,
in un progetto di decoder servo con Arduino (che pilota 5 servo sia in analogico che in DCC, pubblicato qui) ho utilizzato la funzione .detach() che scollega il pin di Arduino dal servo. Ciò ha apparentemente risolto il problema dello scatto all' accensione e i ronzii in alcuni modelli di servo in quanto il servo viene di fatto collegato solo quando deve effettivamente ricevere comandi.
In ogni caso i consigli dati sulle alimentazioni sono sacrosanti, "freddare" la vcc come si dice in gergo è sempre una cosa positiva, una coppia di condensatori, uno al poliestere da 100nF e un elettrolitico da 100-220uF, fa sempre bene
saluti

[sintesi]

Ciao Antonio

grazie per l'input, sfortuna vuole che nel mio caso ho i servo collegati al controller PCA9685 detacharli non posso, proverò indagare in questa direzione
grazie

saluti

[Nick8526]

Io non capisco proprio quale sia il problema.
Se un servocomando ronza è per mantenere la sua posizione quando è sotto sforzo. Non è una questione di disturbi.

Nelle caratteristiche di un servocomando è indicata la forza massima in chilogrammi che esso riesce a mantenere proprio quando è sotto sforzo in base alla distanza che c'è tra l'astina calettata sulla squadretta ed il fulcro del servo.

I servocomandi sono nati per gestire in modo proporzionale i comandi di modelli dinamici come auto, navi, aerei ed elicotteri.
Su un aeromodello, il servo degli alettoni subisce uno sforzo notevole e sicuramente ronzerà, così come farà il servo dello sterzo di una automobile proprio perchè sono sottoposti a sollecitazioni dinamiche.

Se un servo di un motore sottoplancia ronza, è perchè spinge troppo la traversina che muove gli aghi del deviatoio.
Va solo tarata la corsa del servo; inserire condensatori o filtri antidisturbo non serve a nulla.

PS: prendete un servo e comandatelo con un tester per servi, poi provate a forzare la squadretta con le dita e osservate come si comporta.

ciao, secondo me non dipende dallo sforzo, ma nel caso specifico alla meccanica/elettronica del servo.

Alcuni dopo un pò consumano/sporcano le piste dei potenziometri che usano per il controllo posizione, altri magari hanno gli ingraggi che vorrebbero una lubrificata... Sarò brutale nel mio approccio, ma staccando col relais l'alimentazione va benissimo. Alla fine ronzano 10 sec quando viene data corrente per movimentarli e poi si tacciono di nuovo. Purtroppo questi mini servo non si possono aprire per farci manutenzione e visto il costo non ne vale manco la pena...

[Edgardo_Rosatti]

Un piccolo aggiornamento delle schede:

Ho fatto realizzare un numero limitato di schede tramite JLCPCB spendendo relativamente poco (costano più le spese di spedizione che i PCB)
e questo è il risultato:

A sinistra la scheda relè e servi con pulsantiera e a destra la scheda master

Scheda relè e servi + pulsantiera assemblata

Scheda master con display e keypad assemblata

I colori della "soldermask" (bianco e lilla) sono scelti in base ai miei gusti e sono ininfluenti per il funzionamento; si possono richiedere i colori verde,
azzurro, rosso, giallo, lilla, bianco e nero.

La scheda bianca dei relè + servi, ha il tastierino dei pulsanti staccabile tramite una semplice pressione, cioè facendo leva sul PCB è possibile spezzare
con precisione la parte relativa ai pulsanti in quanto è prevista una fresatura chiamata "vcut" per la separazione dei PCB.
Sulla scheda sono presenti 6 relè a doppio deviatore con relativi connettori a 6 poli tipo "strip" a 2 file.
In questo modo, all'azionamento dei servi possono essere gestite anche funzioni tipo polarizzazione del cuore e pilotaggio segnali, o quello che il
modellista ha la necessità di gestire.

Il software è quasi completato e a Novegro 2022 potrete vedere i prototipi in funzione.

Per info sul service JLCPCB:
https://jlcpcb.com/

A lavoro completato verrà aggiornata anche la pagina relativa sul GASTT Lab:
http://gasttlab.altervista.org/gasttlab ... analogico/

[Edgardo_Rosatti]

Aggiornamento software:

Sistema di controllo con un "master" e due "slave"

Nella foto sopra, è possibile vedere 3 schede collegate tra loro; due schede (quelle bianche slave) gestiscono 6 deviatoi ciascuna e 6 relè a doppio deviatore contemporaneamente per un totale di 12 deviatoi.
Le singole schede possono essere comandate anche individualmente tramite il proprio tastierino da 12 tasti (6 x 2, on e off).
Possono essere gestite fino a 128 schede dal master per un totale di 768 deviatoi (6 x 128).
Ogni scheda ha un indirizzo numerico decimale semplice assegnato in fase di programmazione.

Il master (scheda lilla sotto nella foto) è dotata di un display LCD da 16 x 2 caratteri di colore bianco con sfondo azzurro retroilluminato e di un tastierino alfanumerico da 16 tasti (keypad 4 x 4).
La matrice del tastierino è la seguente:
1 2 3 A
4 5 6 B
7 8 9 C
* 0 # D

Scheda master

La composizione del codice per l'azionamento dei servi è così strutturata:
3 cifre per l'indirizzo; esempio, per 1 scrivere 001, per 45 scrivere 045 e per 103 scrivere 103.
In pratica devono essere usati sempre 3 caratteri anteponendo lo zero in caso di unità o decine.
Questo perché il software considera tutti i dati inseriti come caratteri e successivamente effettua delle conversioni interne per trasformare quelli necessari in numeri.

Ad ogni indirizzo corrispondono 6 deviatoi, quindi successivamente deve essere inserito un numero compreso tra 1 e 6 per indicare quale servo (deviatoio) deve essere messo in comunicazione.

Infine vanno digitate le lettera "C" per corretto tracciato o "D" per deviata o non corretto tracciato.

Tutti gli altri caratteri rimanenti, per ora non verranno considerati dal software, così come quando verranno commessi degli errori.
Cioè, se invieremo un comando per comandare il deviatoio 21 dello slave 3427 (che non esiste) non succederà nulla.

In questa foto vediamo come risulta il messaggio per comandare in deviata il deviatoio 5 dello slave 2:

Attivazione in deviata del deviatoio 5 dello slave 2 (codice 0025D)

Questo impianto può sembrare un po' macchinoso, ma ha il vantaggio di essere molto economico se si devono gestire molti deviatoi.

A Novegro 2022 lo porterò montato su un semplice pannello per metterlo a disposizione di chi voglia approfondire o curiosare in merito.

[Edgardo_Rosatti]

É disponibile l'articolo aggiornato definitivamente del progetto sul GASTT Lab a questo url:
http://gasttlab.altervista.org/gasttlab ... analogico/