CODIGO FINAL WALL-E
#include "BluetoothSerial.h"
#include <ESP32Servo.h>
BluetoothSerial SerialBT;
Servo servoMotorL;
Servo servoMotorR;
Servo servoMotorC;
// Pines del motor (Tracción)
const int izqA = 33; //IN1
const int izqB = 25; //IN2
const int derA = 26; //IN3
const int derB = 27; //IN4
// Pin de ojos
const int ojos = 12;
// Pines de los servos
const int pinServoR = 23;
const int pinServoL = 22;
const int pinServoC = 21;
// POSICIONES INDEPENDIENTES PARA CADA SERVO
int posServoR = 90;
int posServoL = 90;
int posServoC = 90;
// CONFIGURACIÓN DEL SENSOR ULTRASÓNICO
const int pinTrigger = 5;
const int pinEcho = 18;
long duracion;
int distancia;
unsigned long ultimoTiempoUltrasonido = 0;
const int intervaloUltrasonido = 60;
char estadoMotores = 'S';
char estadoServoR = 'X'; // 'X' mantiene quieto el brazo derecho
char estadoServoL = 'Y'; // 'Y' mantiene quieto el brazo izquierdo
char estadoServoC = 'W'; // 'W' mantiene quieta la cabeza
char receivedChar;
void setup() {
Serial.begin(9600);
SerialBT.begin("WALL-E");
pinMode(izqA, OUTPUT); pinMode(izqB, OUTPUT);
pinMode(derA, OUTPUT); pinMode(derB, OUTPUT);
pinMode(ojos, OUTPUT); digitalWrite(ojos, LOW);
pinMode(pinTrigger, OUTPUT);
pinMode(pinEcho, INPUT);
servoMotorR.attach(pinServoR); servoMotorR.write(posServoR);
servoMotorL.attach(pinServoL); servoMotorL.write(posServoL);
servoMotorC.attach(pinServoC); servoMotorC.write(posServoC);
Serial.println("WALL-E Modo Paso a Paso Listo");
}
void loop() {
// ========================================================
// PASO 1: MEDICIÓN DEL SENSOR DE ULTRASONIDO
// ========================================================
if (millis() - ultimoTiempoUltrasonido >= intervaloUltrasonido) {
ultimoTiempoUltrasonido = millis();
digitalWrite(pinTrigger, LOW); delayMicroseconds(2);
digitalWrite(pinTrigger, HIGH); delayMicroseconds(10);
digitalWrite(pinTrigger, LOW);
duracion = pulseIn(pinEcho, HIGH, 3000);
distancia = duracion * 0.034 / 2;
if (distancia > 0 && distancia <= 10 && estadoMotores == 'F') {
estadoMotores = 'S';
Serial.println("¡FRENO AUTOMÁTICO POR OBSTÁCULO!");
}
}
// ========================================================
// PASO 2: LEER BLUETOOTH Y MOVER SERVOS AL INSTANTE
// ========================================================
if (SerialBT.available()) {
receivedChar = SerialBT.read();
// Motores de tracción
if (receivedChar == 'F') {
if (distancia > 10 || distancia == 0) estadoMotores = 'F';
}
else if (receivedChar == 'B' || receivedChar == 'L' || receivedChar == 'R' || receivedChar == 'S') {
estadoMotores = receivedChar;
}
// Ojos
else if (receivedChar == 'U') { digitalWrite(ojos, LOW); }
else if (receivedChar == 'V') { digitalWrite(ojos, HIGH); }
// ---- MOVIMIENTO A VOLUNTAD DE LOS SERVOS (SÓLO 3 GRADOS POR PULSO) ----
// Servo Brazo Derecho
else if (receivedChar == 'Q' && posServoR > 0) {
posServoR -= 3; // Modifica este número para cambiar la sensibilidad del botón
if (posServoR < 0) posServoR = 0;
servoMotorR.write(posServoR);
}
else if (receivedChar == 'P' && posServoR < 150) {
posServoR += 3;
if (posServoR > 150) posServoR = 150;
servoMotorR.write(posServoR);
}
// Servo Brazo Izquierdo
else if (receivedChar == 'I' && posServoL > 0) {
posServoL -= 3;
if (posServoL < 0) posServoL = 0;
servoMotorL.write(posServoL);
}
else if (receivedChar == 'Z' && posServoL < 150) {
posServoL += 3;
if (posServoL > 150) posServoL = 150;
servoMotorL.write(posServoL);
}
// Servo Cabeza
else if (receivedChar == 'E' && posServoC > 0) {
posServoC -= 3;
if (posServoC < 0) posServoC = 0;
servoMotorC.write(posServoC);
}
else if (receivedChar == 'A' && posServoC < 180) {
posServoC += 3;
if (posServoC > 180) posServoC = 180;
servoMotorC.write(posServoC);
}
// ========================================================
// REESTABLECER POSICIÓN INICIAL ('H')
// ========================================================
else if (receivedChar == 'H') {
Serial.println("Reestableciendo posición inicial (90°)...");
// 1. Forzamos a que los bucles de movimiento se detengan
estadoServoR = 'X';
estadoServoL = 'Y';
estadoServoC = 'W';
// 2. Actualizamos las variables de posición a 90 grados
posServoR = 90;
posServoL = 90;
posServoC = 90;
// 3. Enviamos la orden física a los servomotores
servoMotorR.write(posServoR);
servoMotorL.write(posServoL);
servoMotorC.write(posServoC);
}
}
// ========================================================
// PASO 3: EJECUTAR ACCIÓN DE LAS RUEDAS
// ========================================================
switch (estadoMotores) {
case 'F': digitalWrite(izqA, HIGH); digitalWrite(izqB, LOW); digitalWrite(derA, HIGH); digitalWrite(derB, LOW); break;
case 'B': digitalWrite(izqA, LOW); digitalWrite(izqB, HIGH); digitalWrite(derA, LOW); digitalWrite(derB, HIGH); break;
case 'L': digitalWrite(izqA, LOW); digitalWrite(izqB, LOW); digitalWrite(derA, HIGH); digitalWrite(derB, LOW); break;
case 'R': digitalWrite(izqA, HIGH); digitalWrite(izqB, LOW); digitalWrite(derA, LOW); digitalWrite(derB, LOW); break;
case 'S': digitalWrite(izqA, LOW); digitalWrite(izqB, LOW); digitalWrite(derA, LOW); digitalWrite(derB, LOW); break;
}
}
_____________________________________________________________________________________________________
CODIGO ARDUINO PARA CONTROLAR UN SERVO CON PULSADOR
#include <Servo.h>
int pulsador1 = 10;
int pulsador2 = 11;
int pos = 0;
int pos1 = 45;
Servo servo_9;
Servo servo_6;
void setup()
{
pinMode(pulsador1,INPUT);
pinMode(pulsador2,INPUT);
servo_9.attach(9);
servo_6.attach(6);
}
void loop()
{
while (digitalRead(pulsador1)== HIGH)
{
// sweep the servo from 0 to 180 degrees in steps
// of 1 degrees
servo_9.write(90);
for (pos = 0; pos <= 180; pos += 1) {
// tell servo to go to position in variable 'pos'
servo_9.write(pos);
// wait 15 ms for servo to reach the position
delay(15); // Wait for 15 millisecond(s)
}
}
while (digitalRead(pulsador2)== HIGH)
{
for (pos = 180; pos >= 0; pos -= 1) {
// tell servo to go to position in variable 'pos'
servo_9.write(pos);
// wait 15 ms for servo to reach the position
delay(15); // Wait for 15 millisecond(s)
}
}
}
___________________________________________________________
CARRO CONTROL ARDUINO
#include <SoftwareSerial.h>
SoftwareSerial BT(2, 3); // RX, TX
char comando;
const int IN1 = 6;
const int IN2 = 5;
const int IN3 = 10;
const int IN4 = 9;
void setup() {
BT.begin(9600);
Serial.begin(9600);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop() {
if (BT.available()) {
comando = BT.read();
Serial.print("Comando recibido: ");
Serial.println(comando);
switch (comando) {
case 'F': // Avanzar
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
break;
case 'B': // Retroceder
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
break;
case 'L': // Izquierda
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
break;
case 'R': // Derecha
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
break;
default: // Detener
detenerMotores();
break;
}
}
}
void detenerMotores() {
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
}
VACACIONAL ROBOTICA SAN GIL
CÓDIGO
#include "BluetoothSerial.h"
#include <ESP32Servo.h> // ✅ Librería compatible con ESP32
BluetoothSerial SerialBT;
Servo servoMotor;
// Pines del motor
const int izqA = 33; //IN1
const int izqB = 25; //IN2
const int derA = 26; //IN3
const int derB = 27; //IN4
// Pin del servo motor
const int pinServo = 14;
char receivedChar;
void setup() {
Serial.begin(9600);
SerialBT.begin("SumoBot");
pinMode(izqA, OUTPUT);
pinMode(izqB, OUTPUT);
pinMode(derA, OUTPUT);
pinMode(derB, OUTPUT);
servoMotor.attach(pinServo); // ✅ Inicializar servo
servoMotor.write(0); // Posición inicial
Serial.println("Carro Bluetooth + Servo listo");
}
void loop() {
if (SerialBT.available()) {
receivedChar = SerialBT.read();
switch (receivedChar) {
case 'F':
digitalWrite(izqA, HIGH);
digitalWrite(izqB, LOW);
digitalWrite(derA, HIGH);
digitalWrite(derB, LOW);
Serial.println("Adelante");
break;
case 'B':
digitalWrite(izqA, LOW);
digitalWrite(izqB, HIGH);
digitalWrite(derA, LOW);
digitalWrite(derB, HIGH);
Serial.println("Atrás");
break;
case 'L':
digitalWrite(izqA, LOW);
digitalWrite(izqB, LOW);
digitalWrite(derA, HIGH);
digitalWrite(derB, LOW);
Serial.println("Izquierda");
break;
case 'R':
digitalWrite(izqA, HIGH);
digitalWrite(izqB, LOW);
digitalWrite(derA, LOW);
digitalWrite(derB, LOW);
Serial.println("Derecha");
break;
case 'S':
digitalWrite(izqA, LOW);
digitalWrite(izqB, LOW);
digitalWrite(derA, LOW);
digitalWrite(derB, LOW);
Serial.println("Stop");
break;
case 'O':
servoMotor.write(90); // Abrir
Serial.println("Servo abierto");
break;
case 'C':
servoMotor.write(0); // Cerrar
Serial.println("Servo cerrado");
break;
}
}
}
DRIVER CH340
LIBRERIA ESP32 https://dl.espressif.com/dl/package_esp32_index.json
____________________________________________-_--__-_----_-____
PRACTICA MOTORES PITIGUAO
const int AIA = 6; // (pwm) pin 6 conectado a pin A-IA
const int AIB = 5; // (pwm) pin 5 conectado a pin A-IB
const int BIA = 10; // (pwm) pin 10 conectado a pin B-IA
const int BIB = 9; // (pwm) pin 9 conectado a pin B-IB
byte velocidad = 160;
// cambie este valor (100 a 255) para controlar
// la velocidad de los motores
void setup() {
pinMode(AIA, OUTPUT); // fijar los pines como salidas
pinMode(AIB, OUTPUT);
pinMode(BIA, OUTPUT);
pinMode(BIB, OUTPUT);
}
void loop() {
izquierda();
delay(2000);
derecha();
delay(2000);
avanzar();
delay(500);
retroceder();
delay(1000);
avanzar();
delay(500);
}
void avanzar()
{
analogWrite(AIA, 0);
analogWrite(AIB, velocidad);
analogWrite(BIA, 0);
analogWrite(BIB, velocidad);
}
void retroceder()
{
analogWrite(AIA, velocidad);
analogWrite(AIB, 0);
analogWrite(BIA, velocidad);
analogWrite(BIB, 0);
}
void izquierda()
{
analogWrite(AIA, velocidad);
analogWrite(AIB, 0);
analogWrite(BIA, 0);
analogWrite(BIB, velocidad);
}
void derecha()
{
analogWrite(AIA, 0);
analogWrite(AIB, velocidad);
analogWrite(BIA, velocidad);
analogWrite(BIB, 0);
}
Ultrasonido
int trig=2;
int echo=3;
int tiempo;
int distancia;
void setup()
{
Serial.begin(9600);
pinMode(trig,OUTPUT);
pinMode(echo,INPUT);
}
void loop()
{
digitalWrite(trig,HIGH);
delay(1);
digitalWrite(trig,LOW);
tiempo=pulseIn(echo,HIGH);
distancia=tiempo/58.2;
Serial.println(distancia);
delay(500);
}
___________________________________________________
/*
Creado: Luis del Valle (ldelvalleh@programarfacil.com)
https://programarfacil.com
*/
// Incluímos la librería para poder controlar el servo
#include <Servo.h>
// Declaramos la variable para controlar el servo
Servo servoMotor;
void setup() {
// Iniciamos el monitor serie para mostrar el resultado
Serial.begin(9600);
// Iniciamos el servo para que empiece a trabajar con el pin 9
servoMotor.attach(9);
}
void loop() {
// Desplazamos a la posición 0º
servoMotor.write(0);
// Esperamos 1 segundo
delay(1000);
// Desplazamos a la posición 90º
servoMotor.write(90);
// Esperamos 1 segundo
delay(1000);
// Desplazamos a la posición 180º
servoMotor.write(180);
// Esperamos 1 segundo
delay(1000);
}
CÓDIGO RADAR ARDUINO
DAR CLIC código PROCESSING
__________________________________________________________________________________
CÓDIGO 8 PWM BLYNK
#define BLYNK_PRINT Serial
#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>
char auth[] = "";
char ssid[] = "";
char pass[] = "";
void setup(){
Serial.begin(9600);
Blynk.begin(auth, ssid, pass, "blynk.cloud", 80);
}
void loop(){
Blynk.run();
}
______________________________________________________________
IMAGEN SCRATCH 4
link proyecto: https://scratch.mit.edu/projects/851929671/
CIRCUITO 1.
CIRCUITO 2
CIRCUITO 3
CIRCUITO 4
________________________________________________________________
BLYNK
#define BLYNK_TEMPLATE_ID "TMPL2a-0jvyzF"
#define BLYNK_TEMPLATE_NAME "Led Test"
#define BLYNK_AUTH_TOKEN "XLZAQWuYvH8vJXuNbJjFWW1VnKjeVXlG"
#include <ESP32Servo.h>
int posicion = 0 ;
Servo miServo;
#define BLYNK_PRINT Serial
//#define BLYNK_DEBUG
#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>
char auth[] = BLYNK_AUTH_TOKEN;
char ssid[] = "Siglo XXI_2.4G";
char pass[] = "SigloxxiA.";
int led1 =18;
int led2 = 25;
int led3 = 16;
int led4 = 14;
int led5 = 15;
int servoPin = 13;
int sensor = 12;
BlynkTimer timer;
void setup()
{
Serial.begin(115200);
delay(100);
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
pinMode(led4,OUTPUT);
pinMode(led5,OUTPUT);
pinMode(27, INPUT);
pinMode(26, OUTPUT);
pinMode(32, OUTPUT);
pinMode(33, OUTPUT);
pinMode(servoPin, OUTPUT);
pinMode(sensor, OUTPUT);
Blynk.begin(auth, ssid, pass);
miServo.attach(servoPin);
miServo.write(0);
pinMode(sensor, INPUT);
}
void loop()
{
if (digitalRead(sensor) == HIGH) {
miServo.write(90);
delay (100);
} else {
miServo.write(0);
delay (100);
}
Blynk.run();
yield();
if ((digitalRead(27) == true)) {
digitalWrite(26, HIGH);
digitalWrite(32, HIGH);
digitalWrite(33, HIGH);
delay(5000);
}
else {
digitalWrite(26, LOW);
digitalWrite(32, LOW);
digitalWrite(33, LOW);
delay(500);
}
}
BLYNK_WRITE(V0){
int state = param.asInt();
digitalWrite(led1,state);
}
BLYNK_WRITE(V1){
int state = param.asInt();
digitalWrite(led2,state);
}
BLYNK_WRITE(V2){
int state = param.asInt();
digitalWrite(led3,state);
}
BLYNK_WRITE(V3){
int state = param.asInt();
digitalWrite(led4,state);
}
BLYNK_WRITE(V4){
int state = param.asInt();
digitalWrite(led5,state);
}
____________________________________________________________________
CONTROL JOYSTICK 2 SERVOS
#include <Servo.h>
//Definicion de los servos
Servo servo1;
Servo servo2;
int eje1=90;
int eje2=90;
void setup(){
servo1.attach(7);
servo2.attach(6);
servo1.write(90);
servo2.write(90);
}
void loop(){
//SERVO 1
if (analogRead(0)<200 && eje1<180){
eje1++;
servo1.write(eje1);
}
if (analogRead(0)>700 && eje1>0){
eje1--;
servo1.write(eje1);
}
//SERVO 2
if (analogRead(1)<200 && eje2<180){
eje2++;
servo2.write(eje2);
}
if (analogRead(1)>700 && eje2>0){
eje2--;
servo2.write(eje2);
}
delay(15);
}
__________________________________________________________
SERVO-PIR 8
#include <Servo.h>
Servo puerta; // Nombre asignado al servo
int LED = 5;
int PIR = 4;
void setup()
{
pinMode(LED, OUTPUT);
pinMode(PIR, INPUT);
puerta.attach(7);
}
void loop()
{
int valorpir = digitalRead(PIR);
if (valorpir == 1) {
digitalWrite(LED, HIGH);
puerta.write(180);
}
else
{
digitalWrite(LED, LOW);
puerta.write(0);
}
delay(300);
}
_____________________________________________
Funcionamiento final pinza robótica 5 grado.
// Constantes
const int anguloCerrado = 40; // Ángulo de la pinza cerrada
const int anguloAbierto = 60; // Ángulo de la pinza abierta
const int buttonPin2 = 2; // Pin del pulsador 1
const int buttonPin3 = 3; // Pin del pulsador 2
// Variables
int buttonState2 = 0; // Variable de lectura del pulsador 1
int buttonState3 = 0; // Variable de lectura del pulsador 2
#include <Servo.h>
Servo myservo;
// Variable para guardar la posición del motor servo
int pos = 80;
void setup() {
// Configuración de inicio
pinMode(buttonPin2, INPUT);
pinMode(buttonPin3, INPUT);
myservo.attach(9);
// Establene la posición inicial de la pinza
myservo.write(68);
delay(1500);
}
void loop() {
pos = constrain(myservo.read(), -anguloAbierto/2 + 90, -anguloCerrado/2 + 90);
// Lee el estado de los pulsadores
buttonState2 = digitalRead(buttonPin2);
buttonState3 = digitalRead(buttonPin3);
// Lee si el pulsador del pin 2 está oprimido
if (buttonState2 == HIGH) {
pos -= 1;
myservo.write(pos);
delay(15);
}
// Lee si el pulsador del pin 3 está oprimido
if (buttonState3 == HIGH) {
pos += 1;
myservo.write(pos);
delay(15);
}
}
___________________________________________________________________________________
CALIBRACION INICIAL SERVO 5
#include <Servo.h>
Servo myservo;
void setup() {
myservo.attach(9);
Serial.begin(9600); // inicia la comunicación con el servo motor
myservo.write(80); // le indica al servo motor que vaya a la posición 80 grados
}
void loop() {
}
_____________________
DHT 11 + OLED PROYECTO FINAL 10
#include "Adafruit_SSD1306.h" //Incluye la librería Adafruit_SSD1306.h
#define OLED_Address 0x3C // Define una constante llamada OLED_Address y le da el valor de 0x3C (el cual es una dirección estandar)
Adafruit_SSD1306 oled(128, 64); // Crea un objeto de pantalla llamado: oled, con una resolución de 128 x 64 pixeles (la misma que tiene nuestra pantalla)
#include "DHTesp.h"
const int DHT_PIN = 15;
DHTesp dhtSensor;
void setup() {
oled.begin(SSD1306_SWITCHCAPVCC, OLED_Address); //inicia el objeto oled y le asigna la dirección contenida en las constante OLED_Address
oled.clearDisplay(); //limpia la pantalla con la funcion .clearDisplay()
oled.setTextSize(2); //función que asigna un tamaño de texto con el valor de 2
dhtSensor.setup(DHT_PIN, DHTesp::DHT11);
}
void loop()
{
TempAndHumidity data = dhtSensor.getTempAndHumidity();
oled.setTextColor(WHITE); //El color del texto será blanco
oled.setCursor(0,0); //Empezaremos a escribir en coordenadas (0,0)
oled.println("T: " + String(data.temperature, 2)+"C");
oled.println("H: " + String(data.humidity, 1)+"%");
oled.writeLine(0,35,128,35,WHITE); //Imprimimos una linea desde el punto (0,32) hasta el punto (128,32)
oled.display();
oled.clearDisplay();
delay(1000);
}
_______________________________________________________
PANTALLA OLED 10
#include <Adafruit_SSD1306.h> //Incluye la librería Adafruit_SSD1306.h
#define OLED_Address 0x3C // Define una constante llamada OLED_Address y le da el valor de 0x3C (el cual es una dirección estandar)
Adafruit_SSD1306 oled(128, 64); // Crea un objeto de pantalla llamado: oled, con una resolución de 128 x 64 pixeles (la misma que tiene nuestra pantalla)
//Inicia la configuración
void setup() {
oled.begin(SSD1306_SWITCHCAPVCC, OLED_Address); //inicia el objeto oled y le asigna la dirección contenida en las constante OLED_Address
oled.clearDisplay(); //limpia la pantalla con la funcion .clearDisplay()
oled.setTextSize(2); //función que asigna un tamaño de texto con el valor de 2
}
//Inicia loop principal
void loop()
{
// Texto en la pantalla oled
oled.setTextColor(WHITE); //El color del texto será blanco
oled.setCursor(0,0); //Empezaremos a escribir en coordenadas (0,0)
oled.print("Hola Mundo"); // Imprimimos en la pantalla la frase "Hola Mundo"
oled.writeLine(0,32,128,32,WHITE); //Imprimimos una linea desde el punto (0,32) hasta el punto (128,32)
oled.writeFillRect(0,50,50,16,WHITE); //Hacemos un rectangulo blanco desde el punto (0,50) hasta el punto (50,16)
oled.display();
}
________________________________________________________________
CODIGO DTH 11
_________________________________________________
OPERACIÓN SCRATCH
LINK: https://scratch.mit.edu/projects/851929671/
________________________________________
PRUEBA BOMBA DE AGUA
int ence = 3;
void setup()
{
pinMode(LED, OUTPUT);
}
void loop()
{
digitalWrite(LED, HIGH);
delay(3000); // Wait for 1000 millisecond(s)
digitalWrite(LED, LOW);
delay(2000); // Wait for 1000 millisecond(s)
}
CALIBRACION SERVO
#include <Servo.h>
Servo myservo;
void setup() {
myservo.attach(9);
Serial.begin(9600); // inicia la comunicación con el servo motor
myservo.write(80); // le indica al servo motor que vaya a la posición 80 grados
}
void loop() {
}
__________________________________________________________
VELOCIMETRO MOTO
int pulsador = 2; //etiqueta para DI2
int estado; //etiqueta para registro
void setup() {
pinMode(pulsador, INPUT_PULLUP); //pin 2 como entrada pull up
Serial.begin(115200); //iniciación de comunicación serial a 9600 baudios
}
void loop() {
estado=digitalRead(pulsador); //guardar estado de DI2 en “estado”
Serial.println(estado); //escritura serial
delay(250); //delay para evitar lecturas erróneas
}
_____________________
