Descripción

---

🧾 Descripción del módulo GY-61 (ADXL335)

📌 Características principales

• Nombre del módulo: GY-61
• Chip sensor: ADXL335
• Tipo de sensor: Acelerómetro analógico de 3 ejes (X, Y, Z)
• Rango de medición: ±3g
• Tensión de operación: 3V–5V (compatible con Arduino)
• Tipo de salida: Analógica (0–3.3V)
• Consumo de corriente: ~350 µA
• Dimensiones: ca. 20mm x 17mm
• Aplicaciones comunes: Detección de movimiento, inclinación, vibraciones, juegos, drones, dispositivos wearables.

📦 Pinout del Módulo

Pin del GY-61	Función
VCC	Alimentación (3.3V o 5V)
GND	Tierra
X	Salida analógica eje X
Y	Salida analógica eje Y
Z	Salida analógica eje Z

---

🛠️ Conexión con Arduino

🔌 Ejemplo de Conexión a un Arduino UNO

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

⚠️ Aunque el módulo puede alimentarse a 5V, el chip ADXL335 funciona nativamente a 3.3V. Algunos módulos GY-61 incorporan un regulador interno.

---

💻 Programmación con Arduino

📄 Código base para leer los valores

// 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);
}

---

📊 Calibración y Conversión en g

El sensor devuelve un valor analógico entre 0 y 1023 (10 bits), proporcional a la tensión de salida (0-3.3V). Para obtener el valor en g, puedes:

1. Calcular la tensión:

float voltageX = (xVal * 3.3) / 1023.0;

2. Convertir en g (sensibilidad ~330 mV/g):

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

🧪 Ejemplo completo con conversión:

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);
}

---

🧭 Aplicaciones prácticas

1. Detección de inclinación
   • Si el módulo está en reposo, la fuerza gravitacional se distribuye entre los ejes.
   • Puedes calcular el ángulo de inclinación entre ejes.
2. Contador de pasos o detector de movimiento
   • Comparando las variaciones rápidas en los valores de los tres ejes.
3. Juguetes o controladores
   • Control con inclinación (tipo joystick).

---

🧰 Consejos útiles

• Utiliza filtros de software (como media móvil) para reducir el ruido.
• Haz una calibración inicial con el módulo en reposo y horizontal.
• Si deseas una mayor precisión, considera el uso de un ADC externo o una alimentación estable a 3.3V.

¡Perfecto! Te propongo dos proyectos separados para el módulo GY-61 con Arduino:

---

📈 Proyecto 1 – Gráfico en tiempo real con Processing

Usa Arduino para leer los datos del GY-61 y Processing para visualizarlos en un gráfico en tiempo real.

🔌 Componentes necesarios

• Arduino UNO (o compatible)
• Módulo GY-61 (ADXL335)
• Cables jumper
• PC con Arduino IDE y 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 (gráfico en tiempo real)

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 puerta serial correcta en el registro de Processing (Serial.list()). Cámbiala si es necesario.

---

💾 Proyecto 2 – Guardar datos en tarjeta SD

🔌 Componentes necesarios

• Arduino UNO
• Módulo GY-61
• Módulo lector MicroSD (tipo Catalex, o basado en chip SPI)
• MicroSD (formateada en FAT32)

---

🧰 Conexiones SD (con módulo SPI clásico)

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

---

📄 Código para leer el acelerómetro + escribir en 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
}

---

📊 Análisis de datos

Puedes abrir el archivo dati.txt exportado en microSD con Excel, Google Sheets o Python para visualizar los datos y crear gráficos.

---

¡Perfecto! A continuación encontrarás dos proyectos completos que te permiten enviar los datos del GY-61 por Bluetooth o Wi-Fi (ESP8266/ESP32) y una introducción a un proyecto móvil con una aplicación Android personalizada para recibirlos y visualizarlos.

---

📡 PROYECTO 1 – Enviar datos por Bluetooth (HC-05 o HC-06)

🔌 Componentes necesarios:

• Arduino UNO
• Módulo GY-61
• Módulo Bluetooth HC-05 o HC-06
• Teléfono inteligente Android con una aplicación tipo Serial Bluetooth Terminal (o tu propia aplicación personalizada)

---

🔧 Conexiones

➤ GY-61 → Arduino:

(Verifica los conectores anteriores: VCC → 3.3V, GND → GND, X → A0, Y → A1, Z → A2)

➤ HC-05 → Arduino:

Puertos HC-05	Arduino UNO
VCC	5V
GND	GND
TXD	Pin 10 (Arduino RX a través de divisor)
RXD	Pin 11 (Arduino TX) a través de resistencias (divisor 1K-2K)

---

🧪 Código 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);
}

✅ Ahora puedes ver los datos en tu smartphone con aplicaciones como «Serial Bluetooth Terminal» o crear tu propia aplicación con MIT App Inventor (ver abajo).

---

🌐 PROYECTO 2 – Envío de datos por Wi-Fi con ESP8266 / ESP32

Puedes elegir:

• ESP8266 + GY-61
• ESP32 con GY-61 (mejor: tiene ADC mejores y Wi-Fi + BLE)

📦 Conexiones

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

---

🌐 Modo 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) + "";
 html += "Y: " + String(y) + "";
 html += "Z: " + String(z) + "";
 html += "</body></html>";

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

✅ Conecta el teléfono al Wi-Fi llamado GY61_WIFI → ve a 192.168.4.1 para ver los datos en vivo!

---

📱 PROYECTO 3 – App Android para recibir datos del acelerómetro

🔧 Opción 1: App con MIT App Inventor (Bluetooth)

Ve a appinventor.mit.edu y construye una sencilla app con:

• Un componente BluetoothClient
• Un Button para conectarte
• Una TextBox o Label para visualizar los datos en tiempo real

📲 Funciones clave:

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

🔧 Opción 2: App en Android Studio (Java/Kotlin)

Para recibir datos a través de Wi-Fi o Bluetooth y dibujarlos con gráficos (tipo line chart), puedes usar:

• BluetoothSocket o HTTP GET
• MPAndroidChart para los gráficos

Si lo deseas, puedo proporcionarte:

• Código App Inventor exportable (.aia)
• Código Kotlin/Java para Android Studio
• Archivo APK para pruebas directas

---

🔁 ¿Quieres todo junto?

Si deseas una solución completa (ESP32 → Wi-Fi → App Android con gráficos), puedo proporcionarte el proyecto full-stack:

• ESP32 que envía datos JSON
• App Android que recibe y dibuja en tiempo real

---

Tutorial: Cómo usar el GY-61

El GY-61 es un módulo acelerómetro de 3 ejes para Arduino ideal para proyectos de movimiento y orientación. Útil para principiantes e intermedios.

Qué necesitas

• Arduino Uno o compatible
• Cable Dupont
• Resistencia de 1 kΩ (para alimentación)
• Conector perfecto 2×10

Pasos

1. 1. Conecta la resistencia de 1 kΩ entre VCC y GND en GY-61.
2. 2. Conecta VCC a 5V en Arduino.
3. 3. Conecta GND en GY-61 a GND en Arduino.
4. 4. Conecta X, Y y Z en Arduino a pines 2, 3 y 4.
5. 5. Carga el siguiente código en Arduino.
6. 6. Verifica los datos de aceleración cada 2 segundos.
7. 7. Consulta el datasheet para detalles adicionales.
8. 8. Prueba a mover el módulo y observa cómo cambian los datos.

Código de ejemplo

```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);
}
```

Miniproyecto

Construye un simple equilibrio horizontal utilizando el GY-61 y un display LCD.

Errores comunes

• No conectar correctamente la resistencia de alimentación.
• Utilizar un Arduino no compatible.
• Olvidar de verificar los datos en el datasheet.
• No utilizar un cable DuPont de alta calidad.

Accesorios recomendados

• Display LCD 16×2
• Batería 3.7V
• Soporte para Arduino
• Cable USB para Arduino

Preguntas frecuentes

¿Cómo puedo verificar si el módulo está funcionando?
Verifica los datos de aceleración con el código proporcionado.

¿El módulo funciona con Arduino Mega?
Sí, el módulo es compatible con Arduino Mega.

¿Cuáles son los límites de precisión del GY-61?
Consulta el datasheet para los detalles exactos, pero el rango es ±16g.