Servomotori controllati tramite joystick.
Descrizione
Questo progetto è un sistema di controllo di due servomotori su due assi basato su Arduino e un modulo joystick standard a due assi. Il joystick fornisce due segnali analogici, uno per l'asse X e uno per l'asse Y, che vengono letti da Arduino e convertiti in angoli per i servomotori compresi tra 0 e 180 gradi. In questo modo, spostando il joystick a sinistra e a destra si controlla il servomotore orizzontale, mentre spostandolo verso l'alto e verso il basso si controlla il servomotore verticale. Questo progetto semplice e pratico è ideale per imparare a leggere gli ingressi analogici di un joystick, controllare i servomotori e creare sistemi di movimento di base. Può essere utilizzato come base per un supporto pan-tilt per telecamere, il controllo di un braccio robotico, un sistema di posizionamento di sensori o qualsiasi progetto che richieda un controllo manuale intuitivo del movimento.
Componenti necessari:
- 1x Arduino UNO
- 2x 5V Servomotore
- 1x 5v modulo joystick a due assi
- Cavi jumper (breadboard opzionale)
Schema:
Codice:
// https://nemiatools.com
#include <Servo.h> // Libreria Servo
#define Horizontal_Servo_Pin 2 // Pin del servo orizzontale
#define Vertical_Servo_Pin 3 // Pin del servo verticale
#define Horizontal_Pot_Pin A0 // Pin del potenziometro orizzontale
#define Vertical_Pot_Pin A1 // Pin del potenziometro verticale
int Servo_Horizontal_Min = 0; // Angolo minimo per il servo orizzontale
int Servo_Horizontal_Max = 180; // Angolo massimo per il servo orizzontale
int Servo_Vertical_Min = 0; // Angolo minimo per il servo verticale
int Servo_Vertical_Max = 180; // Angolo massimo per il servo verticale
Servo Horizontal_Servo; // Crea l'oggetto servo orizzontale
Servo Vertical_Servo; // Crea l'oggetto servo verticale
int Horizontal_Pot_Value; // Memorizza il valore letto dal potenziometro orizzontale
int Horizontal_Servo_Position; // Memorizza la posizione del servo orizzontale
int Vertical_Pot_Value; // Memorizza il valore letto dal potenziometro verticale
int Vertical_Servo_Position; // Memorizza la posizione del servo verticale
void setup()
{
Horizontal_Servo.attach(Horizontal_Servo_Pin); // Collega il servo orizzontale al suo pin
Vertical_Servo.attach(Vertical_Servo_Pin); // Collega il servo verticale al suo pin
}
void loop()
{
Horizontal_Pot_Value = analogRead(Horizontal_Pot_Pin); // Legge il valore del potenziometro orizzontale
Vertical_Pot_Value = analogRead(Vertical_Pot_Pin); // Legge il valore del potenziometro verticale
Horizontal_Servo_Position = map(Horizontal_Pot_Value, 0, 1023, Servo_Horizontal_Min, Servo_Horizontal_Max);
// Converte il valore del potenziometro orizzontale in un angolo del servo
Vertical_Servo_Position = map(Vertical_Pot_Value, 0, 1023, Servo_Vertical_Min, Servo_Vertical_Max);
// Converte il valore del potenziometro verticale in un angolo del servo
Horizontal_Servo.write(Horizontal_Servo_Position); // Muove il servo orizzontale alla posizione calcolata
Vertical_Servo.write(Vertical_Servo_Position); // Muove il servo verticale alla posizione calcolata
delay(20); // Piccolo ritardo
}Come funziona:
Questo progetto utilizza un Arduino per controllare due servomotori tramite un comune modulo joystick a due assi. Il joystick fornisce due uscite analogiche: una per l'asse orizzontale e una per l'asse verticale. Queste uscite sono collegate agli ingressi analogici A0 e A1 dell'Arduino.
All'interno del modulo joystick ci sono due elementi resistivi variabili, uno per ciascun asse. Quando il joystick viene spostato a sinistra, a destra, in alto o in basso, la tensione sull'uscita analogica corrispondente cambia. Arduino legge questi livelli di tensione usando la funzione analogRead(), che li converte in valori compresi tra 0 e 1023.
Il valore orizzontale del joystick viene letto dal pin A0, mentre il valore verticale viene letto dal pin A1. Questi valori rappresentano la posizione attuale del joystick su ciascun asse. Quando il joystick è centrato, i valori sono solitamente circa a metà del range, approssimativamente 512.
Arduino utilizza poi la funzione map() per convertire i valori analogici del joystick in angoli per i servomotori. Poiché i servomotori si muovono da 0 a 180 gradi, l'intervallo di ingresso da 0 a 1023 viene convertito in un intervallo di uscita da 0 a 180 gradi.
Il servomotore orizzontale è collegato al pin digitale 2 ed è controllato dal movimento orizzontale del joystick. Spostare il joystick a sinistra o a destra cambia la posizione di questo servo. Il servomotore verticale è collegato al pin digitale 3 ed è controllato dal movimento verticale del joystick. Spostare il joystick verso l'alto o verso il basso cambia la posizione di questo servo.
Dopo aver calcolato l'angolo corretto per ciascun servo, Arduino invia il comando di posizione usando la funzione Servo.write(). Questo fa ruotare ciascun servomotore fino all'angolo corrispondente alla posizione attuale del joystick.
Il ciclo si ripete continuamente, quindi i servomotori seguono il movimento del joystick in tempo reale. Viene aggiunto un piccolo ritardo di 20 millisecondi per rendere il movimento più fluido e per dare ai servomotori abbastanza tempo per aggiornare la loro posizione.
Questo sistema crea un meccanismo di controllo intuitivo su due assi. Può essere utilizzato in progetti come supporti pan-tilt per telecamere, bracci robotici, sistemi di posizionamento per sensori o qualsiasi applicazione in cui sia necessario un controllo manuale del movimento in due direzioni.
Per un funzionamento stabile, si raccomanda di alimentare i servomotori con un alimentatore esterno adatto, soprattutto quando si usano servo più grandi. Le masse dell'Arduino e dell'alimentatore esterno devono essere collegate insieme.