UNIVERSIDAD DE GUADALAJARA

CENTRO UNIVERSITARIO DE CIENCIAS EXACTAS E INGENIERÍA

Práctica 1

Materia: Diseño de interfaces

Alumno: María Ximena Guzmán Guzmán

Código: 221993433

Correo: [email protected]

Sección: D06

Profesor: Rubén Estrada Marmolejo

29 de octubre de 2024
Introducción
Este proyecto presenta el desarrollo de un sistema móvil con dos ruedas motrices y una rueda adicional de
soporte, controlado por un microcontrolador ESP32-S3 junto con un módulo L298N para la gestión de motores.
La programación del ESP32S se realizó en Arduino, su configuración se realizó mediante una interfaz gráfica
creada en QTCreator. La comunicación entre el microcontrolador y la interfaz se estableció mediante WiFi. Esta
propuesta ofrece una solución funcional y práctica para la movilidad y operación a distancia.

Materiales:

• kit de carrito de dos llantas

• Módulo L298N
• Microcontrolador ESP32-S3
• Voltímetro digital
• Cable USB-A a USB-C
• Cables
• Dos baterías recargables 18650
• Cargador de baterías
• Porta baterías
• Computadora con software QTCreator y Arduino IDE
• Protoboard

Procedimiento y resultados:

Diagrama de la conexión
Implementación en físico

Programación:
Código en Arduino:

#include "BluetoothSerial.h"
#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiClient.h>
#include <ArduinoJson.h>
#include <EEPROM.h>
#include "esp_system.h"
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
#define SERVICE_UUID "7271d0aa-81d1-4c4d-aa45-2eaf95d2c7dd" // UART service UUID
#define CHARACTERISTIC_UUID_RX "7271d0ab-81d1-4c4d-aa45-2eaf95d2c7dd"
#define CHARACTERISTIC_UUID_TX "7271d0ac-81d1-4c4d-aa45-2eaf95d2c7dd"

#define adelanteTiempo 100

#define atrasTiempo 100
#define derechaTiempo 200 // en realidad es en frente
#define izquierdaTiempo 200 // en realidad es atras

BLEServer *pServer = NULL;

BLECharacteristic * pTxCharacteristic;
bool deviceConnected = false;
bool oldDeviceConnected = false;
uint8_t txValue = 0;

WiFiServer servidor(80);

char ssid[100] = "GWN571D04";

char password[100] = "ESP32CUCEI$$";
bool modoServidor = true;
long int tiempoInicio = 0;
long int tiempoFinal = 0;

long int tiempoConexionInicio = 0;

long int tiempoComparacion = 0;
int contador = 0;
String currentLine = "";
bool finMensaje = false;

int motor1A = 12;

int motor1B = 11;
int motor2A = 10;
int motor2B = 9;

long int tiempoMotorInicio = 0;

long int tiempoMotorFin = 0;
bool motorActivado = false;
bool adelante = false;
bool atras = false;
bool derecha = false;
bool izquierda = false;

void pararMotor(){
digitalWrite(motor1A, 0);
digitalWrite(motor1B, 0);
digitalWrite(motor2A, 0);
digitalWrite(motor2B, 0);
}
void configurarMotores(){
pinMode(motor1A, OUTPUT);
pinMode(motor1B, OUTPUT);
pinMode(motor2A, OUTPUT);
pinMode(motor2B, OUTPUT);
pararMotor();
}

void motoresIzquierda(){
digitalWrite(motor1A, HIGH);
digitalWrite(motor1B, LOW);
digitalWrite(motor2A, HIGH);
digitalWrite(motor2B, LOW);
}
void motoresDerecha(){
digitalWrite(motor1A, LOW);
digitalWrite(motor1B, HIGH);
digitalWrite(motor2A, LOW);
digitalWrite(motor2B, HIGH);
}
void motoresAdelante(){
digitalWrite(motor1A, HIGH);
digitalWrite(motor1B, LOW);
digitalWrite(motor2A, LOW);
digitalWrite(motor2B, HIGH);
}
void motoresAtras(){
digitalWrite(motor1A, LOW);
digitalWrite(motor1B, HIGH);
digitalWrite(motor2A, HIGH);
digitalWrite(motor2B, LOW);
}

class MyServerCallbacks: public BLEServerCallbacks {

void onConnect(BLEServer* pServer) {
deviceConnected = true;
};

void onDisconnect(BLEServer* pServer) {

deviceConnected = false;
}
};

class MyCallbacks: public BLECharacteristicCallbacks {

 void onWrite(BLECharacteristic *pCharacteristic) {
// Obtener el valor como String de Arduino
String rxValueArduino = pCharacteristic->getValue();

// Convertir el valor a std::string

std::string rxValueStd = std::string(rxValueArduino.c_str());

// Verificar si el valor recibido tiene contenido

if (rxValueStd.size() > 0) {
/*
Serial.println("*********");
Serial.print("Received Value: ");
for (int i = 0; i < rxValueStd.length(); i++)
Serial.print(rxValueStd[i]);

Serial.println();
Serial.println("*********");
*/

// Verificar si el primer carácter del valor recibido es '1'

if(rxValueStd[0] == '1'){
// Obtener la IP local como String de Arduino
String IP = WiFi.localIP().toString();

// Verificar si el dispositivo está conectado y enviar la IP

if (deviceConnected) {
pTxCharacteristic->setValue(IP.c_str()); // Convertir IP a una cadena estilo C
pTxCharacteristic->notify(); // Notificar el valor al cliente BLE
}
}
}
}
};

void conectaWiFi(){

Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);

WiFi.begin(ssid,password);

while (WiFi.status() != WL_CONNECTED) {

delay(500);
 Serial.print(".");

Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
Serial.println("MAC address: ");
Serial.println(WiFi.macAddress());
//http://sensor1.local
if (!MDNS.begin("sensor1")) {

}
else{
servidor.begin();
MDNS.addService("http", "tcp", 80);
}
}

void conexionURL(){

bool servidorOk = true;

char mensajeJSON[100];
char temporal[50];
char mensajeHTML[400];
char urlVar[10] = "/";
char Servidor[25] = "192.168.43.112";
char Usuario[10] = "bot33";
int j = 0;
for(j = 0; j<=399; j++){
mensajeHTML[j] = '\0';
}
for(j = 0; j<=99; j++){
mensajeJSON[j] = '\0';
}

//Crear el mensaje JSON

sprintf(mensajeJSON, "{\"var\":\"%i\",\"key\":\"sdfsdf\"}", contador);

contador++;

int cuantosBytes = strlen(mensajeJSON);

sprintf(temporal, "POST %s HTTP/1.0\r\n", urlVar);

 strcat(mensajeHTML, temporal);

sprintf(temporal, "Host: %s \r\n", Servidor);

strcat(mensajeHTML, temporal);

sprintf(temporal, "User-Agent: %s \r\n", Usuario);

strcat(mensajeHTML, temporal);

sprintf(temporal,"Content-Length: %i \r\n", cuantosBytes);

strcat(mensajeHTML, temporal);

strcat(mensajeHTML, "Content-Type: application/json\r\n");

strcat(mensajeHTML, "\r\n");
strcat(mensajeHTML, mensajeJSON);

//Serial.println(mensajeHTML);
int cuantosMensaje = strlen(mensajeHTML);
if(servidorOk){
WiFiClient client;
if (client.connect("192.168.43.112", 80)) {
Serial.print("Bytes ara transmitir: ");
Serial.println(cuantosMensaje);
for(j = 0; j<=cuantosMensaje-1; j++){
client.print(mensajeHTML[j]);
Serial.print(mensajeHTML[j]);

}
Serial.println(" ");
delay(1000);
client.stop();
}
else{
Serial.println("Error de conexion con el servidor");
}
}
else{
Serial.print("Bytes ara transmitir: ");
Serial.println(cuantosMensaje);
for(j = 0; j<=cuantosMensaje-1; j++){
Serial.print(mensajeHTML[j]);
}
Serial.println(" ");
}
}
void setup() {
Serial.begin(115200);
configurarMotores();
// Create the BLE Device
BLEDevice::init("UART Service");
 // Create the BLE Server
pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());

// Create the BLE Service

BLEService *pService = pServer->createService(SERVICE_UUID);

// Create a BLE Characteristic

pTxCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID_TX,
BLECharacteristic::PROPERTY_NOTIFY
);

pTxCharacteristic->addDescriptor(new BLE2902());

BLECharacteristic * pRxCharacteristic = pService->createCharacteristic(

CHARACTERISTIC_UUID_RX,
BLECharacteristic::PROPERTY_WRITE
);

pRxCharacteristic->setCallbacks(new MyCallbacks());

// Start the service

pService->start();

// Start advertising
pServer->getAdvertising()->start();
conectaWiFi();
tiempoInicio = millis();
}

void loop() {
if(motorActivado){
tiempoMotorFin = millis();
if(adelante){

if((tiempoMotorFin-tiempoMotorInicio)>adelanteTiempo){
motorActivado = false;
adelante = false;
pararMotor();

}
}
else if(atras){
if((tiempoMotorFin-tiempoMotorInicio)>atrasTiempo){
motorActivado = false;
atras = false;
pararMotor();
 }

}
else if(izquierda){
if((tiempoMotorFin-tiempoMotorInicio)>izquierdaTiempo){
motorActivado = false;
izquierda = false;
pararMotor();

}
else if(derecha){
if((tiempoMotorFin-tiempoMotorInicio)>derechaTiempo){
motorActivado = false;
derecha = false;
pararMotor();

//Para el bluetooth
// disconnecting
if (!deviceConnected && oldDeviceConnected) {
delay(500); // give the bluetooth stack the chance to get things ready
pServer->startAdvertising(); // restart advertising
Serial.println("start advertising");
oldDeviceConnected = deviceConnected;
}
// connecting
if (deviceConnected && !oldDeviceConnected) {
// do stuff here on connecting
oldDeviceConnected = deviceConnected;
}

if(modoServidor){
currentLine = " ";
WiFiClient clienteServidor = servidor.available();
finMensaje = false;
if (clienteServidor) {
tiempoConexionInicio = xTaskGetTickCount();

while(clienteServidor.connected()){
 if(clienteServidor.available() > 0){
char c = clienteServidor.read(); // read a byte, then
//Quiero recibir un mensaje en formato JSON
//{"NombreVariable":"ValorVariable", "NombreVariable2":"ValorVariable2"}
//Ejemplo enviare desde el cliente QT:
//{"pin":"27", "estado":"0"}
//{"pin":"14", "estado":"0"}
//{"pin":"27", "estado":"1"}
//{"pin":"14", "estado":"1"}

Serial.print((char)c); // print it out the serial monitor

///Recibe mensaje JSON - Inicio

if(c == '}'){ finMensaje = true; }
if (c == '\n') { // if the byte is a newline character

// if the current line is blank, you got two newline characters in a row.
// that's the end of the client HTTP request, so send a response:
if (currentLine.length() == 0) {
//Inicia la respuesta
/*

//Termina la respuesta
*/

} else { // if you got a newline, then clear currentLine:

currentLine = "";
}
} else if (c != '\r') { // if you got anything else but a carriage return character,
currentLine += c; // add it to the end of the currentLine
}

if(finMensaje){
String mensajeJSON = currentLine;
//Serial.println(mensajeJSON);
//Decodificacion mensaje JSON - inicio
//StaticJsonBuffer<100> bufferJSON;
//JsonObject& objetoJSON = bufferJSON.parseObject(mensajeJSON);
JsonDocument doc;
deserializeJson(doc, mensajeJSON);
/*
int numeroPin = doc["pin"];
int estadoPin = doc["estado"];
pinMode(numeroPin, OUTPUT);
digitalWrite(numeroPin, estadoPin);
*/
int comando = doc["comando"];
if(comando == 1){
motorActivado = true;
 adelante = true;
tiempoMotorInicio = millis();
motoresAdelante();
}
else if(comando == 2){
motorActivado = true;
atras = true;
tiempoMotorInicio = millis();
motoresAtras();
}
else if(comando == 3){
motorActivado = true;
derecha = true;
tiempoMotorInicio = millis();
motoresDerecha();
}
else if(comando == 4){
motorActivado = true;
izquierda = true;
tiempoMotorInicio = millis();
motoresIzquierda();
}

//Decodificacion mensaje JSON - fin

clienteServidor.println("HTTP/1.1 200 OK");

clienteServidor.println("Content-type:text/html");
clienteServidor.println();

// the content of the HTTP response follows the header:

clienteServidor.println("Configuracion Recibida");

// The HTTP response ends with another blank line:

clienteServidor.println();

//resuestaServidor();

break;

//resuestaServidor();
 //Termina recibir mensaje JSON
tiempoComparacion = xTaskGetTickCount();
if(tiempoComparacion > (tiempoConexionInicio + 3000)){
//clienteServidor.stop();
Serial.println("Error timeout");
break;

}
clienteServidor.stop();
//delay(500);

}
}
else{
tiempoFinal = millis();
if(tiempoFinal > (tiempoInicio+10000)){
tiempoInicio = millis();
//Este if, funcionara cada 2 segundos.
conexionURL();

}
}

}
Código en QT:

MainWindow.cpp

#include "mainwindow.h"

#include "ui_mainwindow.h"

QString nombreRedPrincipal = "wlo1";

QString esp32 = "http://192.168.0.109";

MainWindow::MainWindow(QWidget *parent)

: QMainWindow(parent)

, ui(new Ui::MainWindow)

ui->setupUi(this);

/*

QList<QNetworkInterface> allInterfaces = QNetworkInterface::allInterfaces();

foreach (const QNetworkInterface &interface, allInterfaces) {

qDebug() << "Interface Name:" << interface.humanReadableName();

qDebug() << "IP Address:" << interface.addressEntries().first().ip().toString();

*/

QList<QNetworkInterface> allInterfaces = QNetworkInterface::allInterfaces();

bool interfaceFound = false;

foreach (const QNetworkInterface &interface, allInterfaces) {

if (interface.humanReadableName() == nombreRedPrincipal) {

interfaceFound = true;

qDebug() << "Interfaz encontrada:" << nombreRedPrincipal;

// Aquí puedes continuar con la lógica de conexión

}
 if (!interfaceFound) {

qDebug() << "No se encontró la interfaz:" << nombreRedPrincipal;

MainWindow::~MainWindow()

delete ui;

QString MainWindow::conexionWeb(QString url, QString mensaje, QString nombreRed) {

QString respuesta = "error 1";

// Paso #1: Verificar que la red sea una red funcional.

QNetworkInterface redConectada = QNetworkInterface::interfaceFromName(nombreRed);

QList<QNetworkAddressEntry> lista = redConectada.addressEntries();

// Paso #2: Verificar que la red esté activa.

if (!lista.empty()) {

QNetworkAddressEntry IP = lista.first();

qDebug() << "Red activa: " << IP.ip();

// Crear el mensaje HTML/HTTP

QByteArray longitudMensaje = QByteArray::number(mensaje.size());

QNetworkRequest solicitud;

QNetworkAccessManager *clienteWeb = new QNetworkAccessManager(this); // Manejo de memoria

automático

QUrl servidor(url.toUtf8().constData());

// Paso #3: Verificar que la URL sea válida

if (servidor.isValid()) {

qDebug() << "Servidor válido";

 // Paso #4: Formar el mensaje HTTP

solicitud.setUrl(servidor);

solicitud.setRawHeader(QByteArray("User-Agent"), QByteArray("bot"));

solicitud.setRawHeader(QByteArray("Connection"), QByteArray("close"));

solicitud.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");

solicitud.setHeader(QNetworkRequest::ContentLengthHeader, longitudMensaje);

// Paso #5: Realizar la conexión

QNetworkReply *conexionServidor = clienteWeb->post(solicitud, mensaje.toLatin1());

// Paso #6: Esperar a que el servidor responda

QEventLoop funcionLoop;

QObject::connect(conexionServidor, &QNetworkReply::finished, &funcionLoop, &QEventLoop::quit);

funcionLoop.exec();

// Verificar errores en la respuesta

if (conexionServidor->error() == QNetworkReply::NoError) {

// Paso #7: Leer la respuesta del servidor

QByteArray datosWeb = conexionServidor->readAll();

respuesta = QString(datosWeb);

} else {

respuesta = "Error en la conexión: " + conexionServidor->errorString();

conexionServidor->deleteLater();

} else {

respuesta = "error 3";

} else {

respuesta = "Error 2";

}
 return respuesta;

void MainWindow::on_pushButton_clicked()

qDebug() << conexionWeb(esp32, "{\"comando\":1}", nombreRedPrincipal);

void MainWindow::on_pushButton_2_clicked()

qDebug() << conexionWeb(esp32, "{\"comando\":2}", nombreRedPrincipal)

void MainWindow::on_pushButton_3_clicked()

qDebug() << conexionWeb(esp32, "{\"comando\":3}", nombreRedPrincipal);

void MainWindow::on_pushButton_4_clicked()

qDebug() << conexionWeb(esp32, "{\"comando\":4}", nombreRedPrincipal);

Mainwindow.h

#ifndef MAINWINDOW_H

#define MAINWINDOW_H

#include <QMainWindow>

#include <QtNetwork>

#include <QDebug>

QT_BEGIN_NAMESPACE
namespace Ui {

class MainWindow;

QT_END_NAMESPACE

class MainWindow : public QMainWindow

Q_OBJECT

public:

MainWindow(QWidget *parent = nullptr);

~MainWindow();

public slots:

private slots:

QString conexionWeb(QString url, QString mensaje, QString nombreRed);

void on_pushButton_clicked();

void on_pushButton_2_clicked();

void on_pushButton_3_clicked();

void on_pushButton_4_clicked();

private:

Ui::MainWindow *ui;

};

#endif // MAINWINDOW_H

Main.cpp

#include "mainwindow.h"

#include <QApplication>

int main(int argc, char *argv[])

QApplication a(argc, argv);

MainWindow w;
 w.show();

return a.exec();

Mainwindow.ui