Descrizione

---

🧾 Descrizione del Modulo GY-61 (ADXL335)

📌 Caratteristiche Principali

• Nome Modulo: GY-61
• Chip Sensore: ADXL335
• Tipo di sensore: Accelerometro analogico a 3 assi (X, Y, Z)
• Gamma di misura: ±3g
• Tensione operativa: 3V–5V (compatibile con Arduino)
• Tipo di uscita: Analogica (0–3.3V)
• Consumo di corrente: ~350 µA
• Dimensioni: ca. 20mm x 17mm
• Applicazioni comuni: Rilevamento di movimento, inclinazione, vibrazioni, giochi, droni, dispositivi indossabili.

📦 Pinout del Modulo

Pin del GY-61	Funzione
VCC	Alimentazione (3.3V o 5V)
GND	Massa
X	Uscita analogica asse X
Y	Uscita analogica asse Y
Z	Uscita analogica asse Z

---

🛠️ Collegamento con Arduino

🔌 Esempio di Collegamento a un Arduino UNO

GY-61	Arduino UNO
VCC	3.3V o 5V
GND	GND
X	A0
Y	A1
Z	A2

⚠️ Anche se il modulo può essere alimentato a 5V, il chip ADXL335 funziona nativamente a 3.3V. Alcuni moduli GY-61 integrano un regolatore interno.

---

💻 Programmazione con Arduino

📄 Codice di base per leggere i valori

// Pin analogici
const int xPin = A0;
const int yPin = A1;
const int zPin = A2;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int xVal = analogRead(xPin);
  int yVal = analogRead(yPin);
  int zVal = analogRead(zPin);

  Serial.print("X: ");
  Serial.print(xVal);
  Serial.print(" | Y: ");
  Serial.print(yVal);
  Serial.print(" | Z: ");
  Serial.println(zVal);

  delay(500);
}

---

📊 Calibrazione e Conversione in g

Il sensore restituisce un valore analogico tra 0 e 1023 (10 bit), proporzionale alla tensione di uscita (0-3.3V). Per ottenere il valore in g, puoi:

1. Calcolare la tensione:

float voltageX = (xVal * 3.3) / 1023.0;

2. Convertire in g (sensibilità ~330 mV/g):

float gX = (voltageX - 1.65) / 0.330;  // 1.65V è il valore a 0g

🧪 Esempio completo con conversione:

const int xPin = A0;
const int yPin = A1;
const int zPin = A2;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int xVal = analogRead(xPin);
  int yVal = analogRead(yPin);
  int zVal = analogRead(zPin);

  float voltageX = xVal * 3.3 / 1023.0;
  float voltageY = yVal * 3.3 / 1023.0;
  float voltageZ = zVal * 3.3 / 1023.0;

  float gX = (voltageX - 1.65) / 0.330;
  float gY = (voltageY - 1.65) / 0.330;
  float gZ = (voltageZ - 1.65) / 0.330;

  Serial.print("gX: ");
  Serial.print(gX);
  Serial.print(" | gY: ");
  Serial.print(gY);
  Serial.print(" | gZ: ");
  Serial.println(gZ);

  delay(500);
}

---

🧭 Applicazioni pratiche

1. Rilevamento inclinazione
   • Se il modulo è fermo, la forza gravitazionale si distribuisce tra gli assi.
   • Puoi calcolare l’angolo di inclinazione tra assi.
2. Contapassi o rilevatore di movimenti
   • Confrontando le variazioni rapide sui valori dei tre assi.
3. Giocattoli o controller
   • Controllo con inclinazione (tipo joystick).

---

🧰 Consigli utili

• Utilizza filtri software (come media mobile) per ridurre il rumore.
• Fai una calibrazione iniziale a modulo fermo e orizzontale.
• Se desideri una maggiore precisione, considera l’uso di un ADC esterno o l’alimentazione stabile a 3.3V.

Perfetto! Ti propongo due progetti separati per il modulo GY-61 con Arduino:

---

📈 Progetto 1 – Grafico in tempo reale con Processing

Usa Arduino per leggere i dati dal GY-61 e Processing per visualizzarli in un grafico in tempo reale.

🔌 Componenti necessari

• Arduino UNO (o compatibile)
• Modulo GY-61 (ADXL335)
• Cavi jumper
• PC con Arduino IDE e Processing IDE

---

🔧 1. Sketch Arduino

const int xPin = A0;
const int yPin = A1;
const int zPin = A2;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int x = analogRead(xPin);
  int y = analogRead(yPin);
  int z = analogRead(zPin);

  Serial.print(x);
  Serial.print(",");
  Serial.print(y);
  Serial.print(",");
  Serial.println(z);

  delay(50); // 20 campioni al secondo
}

---

🖥️ 2. Sketch Processing (grafico in tempo reale)

import processing.serial.*;

Serial myPort;
float[] xData = new float[500];
float[] yData = new float[500];
float[] zData = new float[500];

void setup() {
  size(800, 400);
  printArray(Serial.list());
  myPort = new Serial(this, Serial.list()[0], 9600);
  myPort.bufferUntil('n');
}

void draw() {
  background(255);
  strokeWeight(2);

  // Disegna asse
  line(0, height/2, width, height/2);

  drawLine(xData, color(255, 0, 0));
  drawLine(yData, color(0, 255, 0));
  drawLine(zData, color(0, 0, 255));
}

void drawLine(float[] data, color c) {
  stroke(c);
  for (int i = 1; i < data.length; i++) {
    line(i-1, height/2 - data[i-1], i, height/2 - data[i]);
  }
}

void serialEvent(Serial myPort) {
  String inString = myPort.readStringUntil('n');
  if (inString != null) {
    String[] values = trim(split(inString, ","));
    if (values.length == 3) {
      shiftAppend(xData, float(values[0]) - 512); // Centro su 0
      shiftAppend(yData, float(values[1]) - 512);
      shiftAppend(zData, float(values[2]) - 512);
    }
  }
}

void shiftAppend(float[] array, float value) {
  arrayCopy(array, 1, array, 0, array.length - 1);
  array[array.length - 1] = value;
}

⚠️ Verifica la porta seriale corretta nel log di Processing (Serial.list()). Cambiala se necessario.

---

💾 Progetto 2 – Salvataggio dati su scheda SD

🔌 Componenti necessari

• Arduino UNO
• Modulo GY-61
• Modulo lettore MicroSD (tipo Catalex, o basato su chip SPI)
• MicroSD (formattata in FAT32)

---

🧰 Collegamenti SD (con modulo SPI classico)

Modulo SD	Arduino UNO
GND	GND
VCC	5V
MISO	Pin 12
MOSI	Pin 11
SCK	Pin 13
CS (SS)	Pin 10

---

📄 Codice per lettura accelerometro + scrittura su SD

#include <SPI.h>
#include <SD.h>

const int chipSelect = 10;
const int xPin = A0;
const int yPin = A1;
const int zPin = A2;

File dataFile;

void setup() {
  Serial.begin(9600);
  
  if (!SD.begin(chipSelect)) {
    Serial.println("Errore inizializzazione SD!");
    while (1);
  }
  
  dataFile = SD.open("dati.txt", FILE_WRITE);
  if (dataFile) {
    dataFile.println("Tempo(ms),X,Y,Z");
    dataFile.close();
  }
}

void loop() {
  int x = analogRead(xPin);
  int y = analogRead(yPin);
  int z = analogRead(zPin);
  unsigned long t = millis();

  dataFile = SD.open("dati.txt", FILE_WRITE);
  if (dataFile) {
    dataFile.print(t);
    dataFile.print(",");
    dataFile.print(x);
    dataFile.print(",");
    dataFile.print(y);
    dataFile.print(",");
    dataFile.println(z);
    dataFile.close();
  } else {
    Serial.println("Errore scrittura SD.");
  }

  delay(100); // Salva ogni 100ms
}

---

📊 Analisi dei dati

Puoi aprire il file dati.txt esportato sulla microSD con Excel, Google Sheets o Python per visualizzare i dati e creare grafici.

---

Perfetto! Di seguito trovi due progetti completi che ti permettono di inviare i dati del GY-61 via Bluetooth o Wi-Fi (ESP8266/ESP32) e un’introduzione a un progetto mobile con un’app Android personalizzata per riceverli e visualizzarli.

---

📡 PROGETTO 1 – Inviare dati via Bluetooth (HC-05 o HC-06)

🔌 Componenti richiesti:

• Arduino UNO
• Modulo GY-61
• Modulo Bluetooth HC-05 o HC-06
• Smartphone Android con app tipo Serial Bluetooth Terminal (o una tua app personalizzata)

---

🔧 Collegamenti

➤ GY-61 → Arduino:

(Vedi i collegamenti precedenti: VCC → 3.3V, GND → GND, X → A0, Y → A1, Z → A2)

➤ HC-05 → Arduino:

HC-05 Pin	Arduino UNO
VCC	5V
GND	GND
TXD	Pin 10 (Arduino RX via divider)
RXD	Pin 11 (Arduino TX) via resistori (divisore 1K-2K)

---

🧪 Codice Arduino con SoftwareSerial:

#include <SoftwareSerial.h>

SoftwareSerial bt(10, 11); // RX, TX
const int xPin = A0;
const int yPin = A1;
const int zPin = A2;

void setup() {
  bt.begin(9600);
}

void loop() {
  int x = analogRead(xPin);
  int y = analogRead(yPin);
  int z = analogRead(zPin);

  bt.print("X:");
  bt.print(x);
  bt.print(" Y:");
  bt.print(y);
  bt.print(" Z:");
  bt.println(z);

  delay(100);
}

✅ Ora puoi visualizzare i dati sullo smartphone con app tipo “Serial Bluetooth Terminal” o crearne una tua con MIT App Inventor (vedi sotto).

---

🌐 PROGETTO 2 – Invio dati via Wi-Fi con ESP8266 / ESP32

Puoi scegliere:

• ESP8266 + GY-61
• ESP32 con GY-61 (meglio: ha ADC migliori e Wi-Fi + BLE)

📦 Collegamenti

GY-61	ESP32
VCC	3.3V
GND	GND
X	GPIO 34
Y	GPIO 35
Z	GPIO 32

---

🌐 Modalità Wi-Fi Access Point con Web Server

#include <WiFi.h>
#include <WebServer.h>

const char* ssid = "GY61_WIFI";
const char* password = "12345678";

WebServer server(80);

const int xPin = 34;
const int yPin = 35;
const int zPin = 32;

void setup() {
  Serial.begin(115200);

  WiFi.softAP(ssid, password);
  IPAddress IP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(IP);

  server.on("/", handleRoot);
  server.begin();
}

void loop() {
  server.handleClient();
}

void handleRoot() {
  int x = analogRead(xPin);
  int y = analogRead(yPin);
  int z = analogRead(zPin);

  String html = "<html><body><h2>GY-61 Accelerometro</h2>";
  html += "X: " + String(x) + "<br>";
  html += "Y: " + String(y) + "<br>";
  html += "Z: " + String(z) + "<br>";
  html += "</body></html>";

  server.send(200, "text/html", html);
}

✅ Collega il telefono al Wi-Fi chiamato GY61_WIFI → vai su 192.168.4.1 per vedere i dati live!

---

📱 PROGETTO 3 – App Android per ricevere dati accelerometro

🔧 Opzione 1: App con MIT App Inventor (Bluetooth)

Vai su appinventor.mit.edu e costruisci una semplice app con:

• Un componente BluetoothClient
• Un Button per connettersi
• Una TextBox o Label per visualizzare i dati in tempo reale

📲 Funzioni chiave:

• BluetoothClient.Connect("HC-05")
• BluetoothClient.ReceiveText(...)
• TextLabel.Text = received_data

🔧 Opzione 2: App in Android Studio (Java/Kotlin)

Per ricevere i dati via Wi-Fi o Bluetooth e disegnarli con grafico (tipo line chart), puoi usare:

• BluetoothSocket o HTTP GET
• MPAndroidChart per i grafici

Se vuoi, posso fornirti:

• Codice App Inventor esportabile (.aia)
• Codice Kotlin/Java per Android Studio
• File APK per test diretto

---

🔁 Vuoi tutto insieme?

Se desideri una soluzione completa (ESP32 → Wi-Fi → App Android con grafico), posso fornirti il progetto full-stack:

• ESP32 che invia dati JSON
• App Android che riceve e disegna in tempo reale

---

Tutorial: Come usare il GY-61

Il GY-61 è un modulo accelerometro a 3 assi per Arduino ideale per progetti di movimento e orientamento. Utile per principianti e intermedi.

Cosa serve

• Arduino Uno o compatibile
• Cavo DuPont
• Resistenza da 1 kΩ (per alimentazione)
• Connettore perfetto 2×10

Passi

1. 1. Collega la resistenza da 1 kΩ tra VCC e GND su GY-61.
2. 2. Collega VCC a 5V su Arduino.
3. 3. Collega GND su GY-61 a GND su Arduino.
4. 4. Collega X, Y e Z su Arduino a pin 2, 3 e 4.
5. 5. Carica il codice seguente su Arduino.
6. 6. Controlla i dati di accelerazione ogni 2 secondi.
7. 7. Verifica sul datasheet per ulteriori dettagli.
8. 8. Prova a muovere il modulo e osserva i dati cambiare.

Codice di esempio

```cpp
#include <Wire.h>

void setup() {
  Serial.begin(9600);
}

void loop() {
  int16_t ax, ay, az;
  Wire.beginTransmission(0x53);
  Wire.write(0x32);
  Wire.endTransmission();
  Wire.requestFrom(0x53, 6);
  ax = Wire.read() << 8 | Wire.read();
  ay = Wire.read() << 8 | Wire.read();
  az = Wire.read() << 8 | Wire.read();
  Serial.print("ax: "); Serial.println(ax);
  Serial.print("ay: "); Serial.println(ay);
  Serial.print("az: "); Serial.println(az);
  delay(2000);
}
```

Mini-progetto

Costruisci un semplice orizzontale di equilibrio utilizzando il GY-61 e un display LCD.

Errori comuni

• Non collegare correttamente la resistenza di alimentazione.
• Utilizzare un Arduino non compatibile.
• Dimenticare di verificare i dati sul datasheet.
• Non utilizzare un cavo DuPont di alta qualità.

Accessori consigliati

• Display LCD 16×2
• Batteria 3.7V
• Supporto per Arduino
• Cavo USB per Arduino

Domande frequenti

Come posso verificare se il modulo è funzionante?
Verifica i dati di accelerazione con il codice fornito.

Il modulo funziona con Arduino Mega?
Sì, il modulo è compatibile con Arduino Mega.

Quali sono i limiti di precisione del GY-61?
Verifica sul datasheet per i dettagli esatti, ma il range è ±16g.