Micro servo 9g SG90 Motore per modellismo RC elicotteri aerei robotica amatoriale arduino

🛠 Descrizione Completa del Micro Servo 9g SG90

Il Micro Servo SG90 9g è un piccolo servo motore utilizzato comunemente in modellismo RC (elicotteri, aerei), robotica amatoriale, progetti con Arduino e automazione fai-da-te. È apprezzato per la sua leggerezza, basso costo e semplicità d’uso.

✅ Caratteristiche Tecniche:

📦 Contenuto tipico della confezione:

• 1x Micro Servo SG90
• 3x Braccetti (horns)
• 3x Viti

🔌 Collegamento del Micro Servo SG90 con Arduino

⚠️ Nota: Per più servomotori o carichi pesanti, usa un alimentatore esterno (5V) per evitare di sovraccaricare l’Arduino.

🔧 Libreria Necessaria

Arduino ha una libreria ufficiale chiamata Servo.h che semplifica molto l’uso dei servo.

📦 Installazione (se non già presente):

• Apri l’IDE Arduino
• Vai su: Sketch > Include Library > Manage Libraries…
• Cerca “Servo” e installa quella ufficiale di Arduino

🧪 Esempio di Codice Base

🎯 Obiettivo: Far ruotare il servo da 0° a 180° e ritorno

#include <Servo.h>

Servo mioServo; // Crea un oggetto servo

void setup() {
  mioServo.attach(9); // Collega il servo al pin 9
}

void loop() {
  for (int angolo = 0; angolo <= 180; angolo++) {
    mioServo.write(angolo);      // Imposta l'angolo
    delay(15);                   // Attendi che il servo si muova
  }
  delay(500);
  for (int angolo = 180; angolo >= 0; angolo--) {
    mioServo.write(angolo);
    delay(15);
  }
  delay(500);
}

💡 Esempi Avanzati di Utilizzo

📍 Controllo tramite potenziometro

#include <Servo.h>

Servo mioServo;
int potPin = A0; // Potenziometro collegato ad A0

void setup() {
  mioServo.attach(9);
}

void loop() {
  int lettura = analogRead(potPin);          // Legge il valore (0–1023)
  int angolo = map(lettura, 0, 1023, 0, 180); // Lo converte in gradi
  mioServo.write(angolo);
  delay(10);
}

🎮 Controllo via seriale

#include <Servo.h>

Servo mioServo;

void setup() {
  Serial.begin(9600);
  mioServo.attach(9);
  Serial.println("Inserisci un angolo tra 0 e 180:");
}

void loop() {
  if (Serial.available() > 0) {
    int angolo = Serial.parseInt();
    if (angolo >= 0 && angolo <= 180) {
      mioServo.write(angolo);
      Serial.print("Angolo impostato a: ");
      Serial.println(angolo);
    } else {
      Serial.println("Valore non valido. Inserisci 0-180.");
    }
  }
}

📚 Consigli di Utilizzo

• Non forzare il servo oltre i suoi limiti meccanici (generalmente 0°–180°).
• Evita di alimentare più servo direttamente dal 5V di Arduino, usa un alimentatore esterno da 5V/2A per stabilità.
• I servo SG90 non sono adatti per rotazione continua: se ti serve un motore che ruoti liberamente, considera i servo a rotazione continua o i motoriduttori.

⚙️ Applicazioni Comuni

• Controllo timone/alettoni su modellini RC
• Movimento braccia robotiche
• Serrature elettroniche
• Meccanismi animatronici
• Puntamento sensori o camere (pan/tilt)

Perfetto! Espandiamo la guida per includere:

1. ✅ Controllo Wireless con Bluetooth (HC-05)
2. ✅ Controllo via Wi-Fi con ESP8266/ESP32
3. ✅ Controllo di più servo contemporaneamente
4. ✅ Integrazione con sensori (es. distanza ultrasuoni HC-SR04)

🟦 1. Controllo Wireless con Modulo Bluetooth HC-05

🎯 Obiettivo:

Comandare il servo SG90 via Bluetooth da un’app sullo smartphone (es. app come Serial Bluetooth Terminal su Android).

🔌 Collegamento HC-05:

⚠️ Usa un partitore resistivo (1kΩ + 2kΩ) per abbassare il segnale da 5V a 3.3V verso l’RXD del modulo HC-05.

🔧 Codice Arduino con SoftwareSerial:

#include <Servo.h>
#include <SoftwareSerial.h>

Servo mioServo;
SoftwareSerial BT(10, 11); // RX, TX

void setup() {
  mioServo.attach(9);
  BT.begin(9600);
}

void loop() {
  if (BT.available()) {
    int angolo = BT.parseInt();
    if (angolo >= 0 && angolo <= 180) {
      mioServo.write(angolo);
    }
  }
}

🔄 Test: Invia da app mobile un numero tra 0 e 180.

🌐 2. Controllo Servo via Wi-Fi (ESP8266 o ESP32)

⚠️ Se usi ESP8266 o ESP32, NON usare Arduino UNO. I pin sono diversi e il servo va alimentato con cura.

🧠 Esempio con ESP8266 (NodeMCU):

• Servo → alimentato con fonte esterna 5V e GND condiviso
• Segnale → collegato a D1 (GPIO 5)

🔧 Codice base per web server che controlla il servo:

#include <ESP8266WiFi.h>
#include <Servo.h>

Servo mioServo;
const char* ssid = "TuaReteWiFi";
const char* password = "PasswordWiFi";

WiFiServer server(80);

void setup() {
  mioServo.attach(D1); // GPIO 5
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
  server.begin();
}

void loop() {
  WiFiClient client = server.available();
  if (client) {
    String req = client.readStringUntil('\r');
    client.flush();

    if (req.indexOf("/angle=") != -1) {
      int angolo = req.substring(req.indexOf("=")+1).toInt();
      if (angolo >= 0 && angolo <= 180) {
        mioServo.write(angolo);
      }
    }

    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: text/html");
    client.println("");
    client.println("<html><body>");
    client.println("<h1>Controllo Servo</h1>");
    client.println("<form>Angolo (0-180): <input type='number' name='angle'><input type='submit'></form>");
    client.println("</body></html>");
  }
}

💻 Vai all’indirizzo IP assegnato (es. 192.168.1.42) nel browser.

⚙️ 3. Controllare Più Servo Contemporaneamente

#include <Servo.h>

Servo servo1, servo2, servo3;

void setup() {
  servo1.attach(9);
  servo2.attach(10);
  servo3.attach(11);
}

void loop() {
  for (int ang = 0; ang <= 180; ang++) {
    servo1.write(ang);
    servo2.write(180 - ang);
    servo3.write(ang / 2);
    delay(15);
  }
}

✅ Ogni Servo viene collegato a un pin diverso. Arduino UNO può gestire fino a 12 servo, ma con limiti di alimentazione!

📏 4. Controllo Servo con Sensore di Distanza HC-SR04

🎯 Obiettivo:

Far muovere il servo in base alla distanza letta dal sensore ultrasuoni.

🔌 Collegamenti:

🔧 Codice:

#include <Servo.h>

Servo mioServo;
const int trigPin = 7;
const int echoPin = 6;

void setup() {
  Serial.begin(9600);
  mioServo.attach(9);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  // Invio impulso
  digitalWrite(trigPin, LOW); delayMicroseconds(2);
  digitalWrite(trigPin, HIGH); delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  long durata = pulseIn(echoPin, HIGH);
  float distanza = durata * 0.034 / 2;

  int angolo = map(distanza, 5, 100, 0, 180); // Da 5 cm a 100 cm
  angolo = constrain(angolo, 0, 180);

  mioServo.write(angolo);
  delay(100);
}

🔚 Conclusione e Possibili Estensioni

✅ Ora puoi:

• Controllare il servo via Bluetooth, Wi-Fi o sensori
• Gestire più servo per robotica o bracci articolati
• Integrare input da remoto o ambiente (es. distanza, potenziometri)

Perfetto! Approfondiamo i due aspetti per un robot con braccio articolato controllato da servo SG90:

🦾 1. Sincronizzazione dei movimenti servo (Braccio Robotico)

🎯 Obiettivo:

Coordinare più servo (es. spalla, gomito, polso) per far compiere movimenti fluidi e sincronizzati a un braccio robotico.

🎮 Esempio: 3 DOF (gradi di libertà)

🔌 Collegamenti:

🔧 Codice sincronizzato:

#include <Servo.h>

Servo servoSpalla;
Servo servoGomito;
Servo servoPolso;

void setup() {
  servoSpalla.attach(9);
  servoGomito.attach(10);
  servoPolso.attach(11);
}

void loop() {
  // Esegui una sequenza sincrona
  for (int ang = 0; ang <= 90; ang++) {
    servoSpalla.write(ang);
    servoGomito.write(90 - ang);
    servoPolso.write(ang / 2);
    delay(20); // Tempo per il movimento fluido
  }

  delay(1000); // Pausa

  for (int ang = 90; ang >= 0; ang--) {
    servoSpalla.write(ang);
    servoGomito.write(90 - ang);
    servoPolso.write(ang / 2);
    delay(20);
  }

  delay(1000);
}

✅ Tutti i servomotori si muovono in modo coordinato e si possono modificare le relazioni per creare movimenti articolati.

💾 2. Memorizzazione delle posizioni servo

🧠 Obiettivo:

Salvare delle “pose” del braccio robotico in memoria (EEPROM) o da inviare via seriale, per poi richiamarle con un comando.

📦 Soluzione 1: Memorizzare in EEPROM (persistente dopo riavvio)

#include <Servo.h>
#include <EEPROM.h>

Servo s1, s2, s3;

void setup() {
  s1.attach(9);
  s2.attach(10);
  s3.attach(11);

  // Carica posizione salvata all'avvio
  int a1 = EEPROM.read(0);
  int a2 = EEPROM.read(1);
  int a3 = EEPROM.read(2);

  s1.write(a1);
  s2.write(a2);
  s3.write(a3);
  delay(1000);
}

void loop() {
  // Sposta braccio in nuova posizione
  s1.write(60);
  s2.write(120);
  s3.write(90);
  delay(2000);

  // Salva questa "pose" nella EEPROM
  EEPROM.write(0, 60);  // s1
  EEPROM.write(1, 120); // s2
  EEPROM.write(2, 90);  // s3

  while (1); // Ferma il loop
}

💾 Quando riavvii Arduino, il braccio tornerà nella posizione salvata.

📦 Soluzione 2: Inviare pose da Serial Monitor e salvarle in RAM

#include <Servo.h>

Servo s1, s2, s3;
int pos[3];

void setup() {
  Serial.begin(9600);
  s1.attach(9);
  s2.attach(10);
  s3.attach(11);

  Serial.println("Invia tre valori separati da virgole (es. 30,90,120):");
}

void loop() {
  if (Serial.available()) {
    String input = Serial.readStringUntil('\n');
    input.trim();

    int idx1 = input.indexOf(',');
    int idx2 = input.lastIndexOf(',');

    if (idx1 > 0 && idx2 > idx1) {
      pos[0] = input.substring(0, idx1).toInt();
      pos[1] = input.substring(idx1 + 1, idx2).toInt();
      pos[2] = input.substring(idx2 + 1).toInt();

      s1.write(pos[0]);
      s2.write(pos[1]);
      s3.write(pos[2]);

      Serial.println("Posizione eseguita.");
    } else {
      Serial.println("Formato errato. Usa: ang1,ang2,ang3");
    }
  }
}

📱 Puoi inviare pose da PC o Bluetooth. Esempio: 45,90,135

➕ Estensione Avanzata (Opzionale)

✅ Memorizzare più pose in EEPROM con tasti per richiamarle
✅ Salvare sequenze animate per playback
✅ Interfaccia via web (ESP32) per programmare movimenti da browser
✅ Joystick per controllare il braccio in tempo reale e poi “registrare”

🔚 Conclusione

Con queste soluzioni puoi:

• Far muovere il braccio come un sistema articolato
• Memorizzare pose o sequenze personalizzate
• Integrare con comandi da remoto (Bluetooth, Wi-Fi o seriale)