Un cargador de teléfono automático: 6 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:44

"Este instructable fue creado en cumplimiento del requisito del proyecto de Makecourse en la Universidad del Sur de Florida (www.makecourse.com)"

La idea detrás de este proyecto era crear un dispositivo que pudiera cargar un teléfono y luego desenchufarlo cuando el teléfono alcanzara el 100%. Esto detendría los problemas de sobrecarga.

Paso 1: componentes de plástico

Se utilizaron algunos componentes que se imprimieron en 3D. Estos componentes comprendían una base, un soporte para el cargador, un conjunto de engranajes de piñón y cremallera (un engranaje normal y una pieza lineal que cambia la rotación a movimiento lineal) y una base para que todo funcione. Estos componentes se explicarán en los siguientes párrafos. En orden de aparición

Soporte de cargador

El propósito de esto es sostener el cargador del teléfono, o al menos darle una base mejor y nivelada sobre la cual estar.

Base

La base tiene anillos para el soporte del teléfono, así como una pista para el juego de engranajes.

Soporte para teléfono

Sostiene el teléfono, obviamente

Brazo del teléfono

Mueve y sostiene el teléfono

Conjunto de engranajes de piñón y cremallera

Se usa para mover el cargador del teléfono hacia adelante y hacia atrás

Paso 2: Desglose de componentes no impresos en 3D

Estos son los componentes que se compraron para el proyecto o que ya eran de su propiedad. Para algunas de las partes que les vinculé / artículos similares en Amazon, pero siéntase libre de adquirirlos en cualquier lugar.

Micro Servo:

Servo estándar 0-180:

Módulo serie Bluetooth HC-05:

Teléfono y cargador de teléfono

Arduino

Tablero de circuitos

Caja o papelera para base

Sensor táctil:

Paso 3: Electrónica

Sin embargo, el circuito para este proyecto puede requerir algo, principalmente debido al módulo HC-05. Muchos de los módulos de este tipo tienen una tasa de aproximadamente 3.3V a 6V, que se encuentra en el rango operativo del Arduino. Pero, para la comunicación en serie, el pin Rx a veces funciona mejor con solo 3.3V. Como se ve en el diagrama anterior, los dos servos están conectados al pin Vin del Arduino. Este voltaje adicional puede ser suministrado por cualquier cosa, usé una batería de 9 voltios. El sensor táctil se conectó al 5V en el Arduino. Esto se debió a que todos los componentes tenían problemas para funcionar con el mismo voltaje. El sensor táctil está conectado al pin 2 para que pueda usarse como una interrupción de pin. Luego, el módulo bluetooth se conecta a los pines Rx y Tx para la comunicación en serie. Entre el pin Rx en el módulo y Tx en el Arduino hay una resistencia de 2 kilo ohmios con una conexión de 1 kilo ohmio a tierra. Esto ayuda a regular el voltaje que entra.

Paso 4: Montaje

El montaje es bastante sencillo.

1. con un poco de pegamento, monta tus servos en sus posiciones, uno para el engranaje por el recorte en la base y otro cerca de donde está la base del teléfono.
2. Conecte el sensor táctil al soporte del teléfono, para que pueda saber cuándo está el teléfono.
3. Luego conecte el engranaje y el brazo a sus respectivos servos
4. Asegúrese de que los cables no interfieran con otros componentes mientras llena sus dispositivos electrónicos.

Paso 5: Código

Hay tres conjuntos de código que se presentarán, un código para Arduino, que se creó en el IDE de Arduino y dos códigos que se crearon en Android Studio. Las aplicaciones de Android son las mismas, excepto que una es la aplicación completa que rastrea la duración de la batería y la otra no. El segundo es para fines de prueba.

Código Arduino

El punto principal de este código es operar el sensor táctil y los motores, recibe un comando del teléfono y actúa sobre él.

#include // llama a la biblioteca de servos para que podamos controlar los dos servosServo servo1; Servo servo2; // crea dos objetos servo para cada servomotor int a = 0; // variable de seguimiento para la prueba int q = 0; // una variable que permite que haya un retraso antes de que comience el proceso de conexión char c; // variable que contiene el mensaje en serie del teléfono void setup () {attachInterrupt (digitalPinToInterrupt (2), AH, FALLING); // adjunta una interrupción descendente para saber exactamente cuándo el sensor táctil ve cuando el teléfono está saliendo en servo1.attach (10); servo2.attach (9); // inicializa los dos servos Serial.begin (9600); // comienza la comunicación serial a una velocidad similar a la del módulo bluetooth servo2.write (20); // auto configura los servos a una posición inicial servo1.write (180); }

bucle vacío () {

if (Serial.available ()) {// esto verifica si hay algo entrando desde el teléfono a través de los pines seriales Tx y Rx c = Serial.read (); // lee lo que viene de if (c == 't') {// si el dispositivo serial lee entonces eso significa que el teléfono está completamente cargado, el proceso de desconexión comienza servo2.write (120); // desconecta el retraso del cargador (5000); // espera para asegurarse hay tiempo para la eliminación servo1.write (110); // mueve el teléfono a una posición vertical para señalar //Serial.println("here "); attachInterrupt (digitalPinToInterrupt (2), AH, FALLING); // vuelve a conectar la interrupción}} if (q == 1) {// si la condición para el enchufado es ture, entonces comience con la conexión del retardo del cargador (10000); servo2.write (0); // mueve el servo a la posición q = 0; // restablece la condición}}

void AH () {

//Serial.println("in "); servo1.write (180); // coloca la plataforma del teléfono en la posición de carga q = 1; // inicia la condición para continuar el proceso // a = 1; detachInterrupt (digitalPinToInterrupt (2)); // separa la interrupción, para que no haya problemas con la interrupción que comienza cuando no debería}

Aplicación Android

Aquí solo mostraré la aplicación adecuada, pero también se proporcionará el archivo de código de prueba, la única diferencia será la eliminación de la clase ejecutable y getBattery. El código de serie mencionado es el estándar para teléfonos que se conectan a dispositivos como el módulo.

paquete com.example.daniel.make; importar android.bluetooth. BluetoothAdapter; importar android.bluetooth. BluetoothDevice; importar android.bluetooth. BluetoothSocket; importar android.os. Handler; importar android.support.v7.app. AppCompatActivity; importar android.os. Bundle; importar android.content. Intent; importar android.content. IntentFilter; importar android.os. BatteryManager; import java.io. IOException; import java.io. OutputStream; import java.util. Set; import java.util. UUID;

public class MainActivity extiende AppCompatActivity {

// creando objetos necesarios Handler handler; // ayuda con el bucle Runnable runnable; // ejecuta continuamente BluetoothAdapter mBluetoothAdapter; BluetoothSocket mmSocket; BluetoothDevice mmDevice; OutputStream mmOutputStream; stopWorker booleano volátil; OutputStream privado outputStream; Cadena final privada DEVICE_NAME = "HC-05"; UUID final privado PORT_UUID = UUID.fromString ("00001101-0000-1000-8000-00805f9b34fb"); dispositivo BluetoothAdapter privado; toma BluetoothSocket privada; @Override protected void onCreate (Bundle SavedInstanceState) {// es un conjunto de instrucciones que se ejecutan cuando se crea la aplicación super.onCreate (SavedInstanceState); // muestra una creación setContentView (R.layout.activity_main); runnable = new Runnable () {@Override public void run () {// se ejecuta repetidamente int level = (int) getBattery (); // obtiene el nivel de batería actual if (level == 100) {// si el nivel de batería alcanza el 100% try {getBT (); // se conecta al módulo bluetooth openBT (); // lo abre sendData (); // envía los datos necesarios closeBT (); // cierra el objeto} catch (IOException ex) { }} handler.postDelayed (ejecutable, 5000); // un retraso}}; handler = new Handler (); handler.postDelayed (ejecutable, 0); }

public float getBattery () {

Intent batteryIntent = registerReceiver (null, new IntentFilter (Intent. ACTION_BATTERY_CHANGED)); // crea la acción que se conecta a la batería int level = batteryIntent.getIntExtra (BatteryManager. EXTRA_LEVEL, -1); // obtiene el nivel de mejora int scale = batteryIntent.getIntExtra (BatteryManager. EXTRA_SCALE, -1); // obtiene la escala de la batería if (level == -1 || scale == -1) {// en caso de error return 50.0f; } float batt = (level / (float) scale) * 100.0f; // obtiene la escala adecuada return batt; // devuelve el nivel}

void getBT () {// obtiene las posibles conexiones bluetooth

mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter (); // obtiene el adaptador if (! mBluetoothAdapter.isEnabled ()) {// se asegura de que el teléfono sea compatible con Intent enableBluetooth = new Intent (BluetoothAdapter. ACTION_REQUEST_ENABLE); // solicita que sea encendido si no es startActivityForResult (enableBluetooth, 0); } Set pairedDevices = mBluetoothAdapter.getBondedDevices (); // obtiene la lista de dispositivos bluetooth enlazados if (pairedDevices.size ()> 0) {// se asegura de que haya algunos dispositivos para (BluetoothDevice device: pairedDevices) {// recorre el dispositivos if (device.getName (). equals ("HC-05")) {// comprueba si es el correcto mmDevice = dispositivo; // lo guarda romper; }}}}

void openBT () lanza IOException {

UUID uuid = UUID.fromString ("00001101-0000-1000-8000-00805f9b34fb"); // Estándar // SerialPortService ID mmSocket = mmDevice.createRfcommSocketToServiceRecord (uuid); // se conecta al dispositivo con la identificación adecuada mmSocket.connect (); // conecta mmOutputStream = mmSocket.getOutputStream (); // inicia la capacidad de enviar datos al módulo arduino}

void sendData () lanza IOException {// clase que envía la t al arduino

mmOutputStream.write ('t'); }

void closeBT () throws IOException {// cierra todas las conexiones al arduino

stopWorker = verdadero; mmOutputStream.close (); mmSocket.close (); }}

Paso 6: archivos

Gracias por leer, se adjuntan los archivos que se utilizaron en este proyecto.