RoboCode es la plataforma perfecta para estudiantes, profesionales y entusiastas de la robótica. Aquí podrás aprender, compartir y colaborar en proyectos increíbles de Arduino, Python, JavaScript, C++ y más.
Nuestra comunidad está creciendo cada día con personas apasionadas por la tecnología y la innovación. ¡Únete a nosotros y comparte tus proyectos con el mundo!
Accede a guías completas y tutoriales paso a paso de proyectos de robótica. Desde nivel principiante hasta avanzado, aprende a programar Arduino, controlar servomotores, usar sensores y mucho más.
Desarrolla tus propios proyectos de robótica utilizando Arduino, Raspberry Pi, Python, C++ y JavaScript. Construye robots, sistemas automatizados y dispositivos IoT innovadores.
Publica tus proyectos con código, imágenes y descripciones detalladas. Inspira a otros makers de la comunidad y recibe feedback para mejorar tus creaciones robóticas.
Conecta con una comunidad global de entusiastas de la robótica. Comparte conocimientos, resuelve dudas y trabaja en proyectos colaborativos con makers de todo el mundo.
Explora nuestras guías paso a paso para crear proyectos increíbles de robótica
Aprende a controlar un brazo robótico de 4 servomotores con Arduino. Ideal para principiantes.
Construye un robot autónomo que sigue líneas negras usando sensores infrarrojos.
Crea un robot que detecta y evita obstáculos usando sensor ultrasónico HC-SR04.
Controla tu robot desde tu smartphone usando módulo Bluetooth HC-05.
Crea animaciones y mensajes en una matriz LED 8x8 con Arduino.
Sistema avanzado con múltiples sensores: temperatura, humedad, presión y calidad del aire.
Control preciso de robot con joystick analógico y velocidad variable.
Alarma con sensor de movimiento PIR, teclado de acceso y buzzer.
Este proyecto te enseña a controlar un brazo robótico de 4 servomotores usando Arduino. El código permite controlar cada articulación del brazo de forma precisa, ideal para aprender sobre servomotores y control de movimiento en robótica.
#include <Servo.h>
// Declaración de servomotores
Servo servoBase;
Servo servoHombro;
Servo servoCodo;
Servo servoPinza;
const int pinBase = 3;
const int pinHombro = 5;
const int pinCodo = 6;
const int pinPinza = 9;
int posBase = 90;
int posHombro = 90;
int posCodo = 90;
int posPinza = 90;
void setup() {
servoBase.attach(pinBase);
servoHombro.attach(pinHombro);
servoCodo.attach(pinCodo);
servoPinza.attach(pinPinza);
servoBase.write(posBase);
servoHombro.write(posHombro);
servoCodo.write(posCodo);
servoPinza.write(posPinza);
Serial.begin(9600);
Serial.println("Brazo Robotico Iniciado");
}
void loop() {
if (Serial.available() > 0) {
char comando = Serial.read();
int valor = Serial.parseInt();
valor = constrain(valor, 0, 180);
switch(comando) {
case 'b':
posBase = valor;
servoBase.write(posBase);
break;
case 'h':
posHombro = valor;
servoHombro.write(posHombro);
break;
case 'c':
posCodo = valor;
servoCodo.write(posCodo);
break;
case 'p':
posPinza = valor;
servoPinza.write(posPinza);
break;
}
}
delay(15);
}
Construye un robot que sigue automáticamente una línea negra sobre fondo blanco. Perfecto para competencias de robótica.
// Pines de sensores IR
const int sensorIzq = 2;
const int sensorDer = 3;
// Pines del motor izquierdo
const int motorIzqA = 5;
const int motorIzqB = 6;
// Pines del motor derecho
const int motorDerA = 9;
const int motorDerB = 10;
const int velocidad = 150;
void setup() {
pinMode(sensorIzq, INPUT);
pinMode(sensorDer, INPUT);
pinMode(motorIzqA, OUTPUT);
pinMode(motorIzqB, OUTPUT);
pinMode(motorDerA, OUTPUT);
pinMode(motorDerB, OUTPUT);
Serial.begin(9600);
}
void loop() {
int izq = digitalRead(sensorIzq);
int der = digitalRead(sensorDer);
if (izq == LOW && der == LOW) {
adelante();
} else if (izq == HIGH && der == LOW) {
girarIzquierda();
} else if (izq == LOW && der == HIGH) {
girarDerecha();
} else {
detener();
}
}
void adelante() {
analogWrite(motorIzqA, velocidad);
analogWrite(motorIzqB, 0);
analogWrite(motorDerA, velocidad);
analogWrite(motorDerB, 0);
}
void girarIzquierda() {
analogWrite(motorIzqA, 0);
analogWrite(motorIzqB, velocidad);
analogWrite(motorDerA, velocidad);
analogWrite(motorDerB, 0);
}
void girarDerecha() {
analogWrite(motorIzqA, velocidad);
analogWrite(motorIzqB, 0);
analogWrite(motorDerA, 0);
analogWrite(motorDerB, velocidad);
}
void detener() {
analogWrite(motorIzqA, 0);
analogWrite(motorIzqB, 0);
analogWrite(motorDerA, 0);
analogWrite(motorDerB, 0);
}
Robot autónomo que detecta obstáculos y cambia de dirección automáticamente usando sensor ultrasónico.
// Sensor ultrasónico
const int trigPin = 12;
const int echoPin = 11;
// Motores
const int motorIzqA = 5;
const int motorIzqB = 6;
const int motorDerA = 9;
const int motorDerB = 10;
const int velocidad = 180;
const int distanciaMinima = 20; // cm
void setup() {
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(motorIzqA, OUTPUT);
pinMode(motorIzqB, OUTPUT);
pinMode(motorDerA, OUTPUT);
pinMode(motorDerB, OUTPUT);
Serial.begin(9600);
}
void loop() {
long distancia = medirDistancia();
Serial.print("Distancia: ");
Serial.println(distancia);
if (distancia > distanciaMinima) {
adelante();
} else {
detener();
delay(300);
retroceder();
delay(500);
girarDerecha();
delay(600);
}
delay(50);
}
long medirDistancia() {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
long duracion = pulseIn(echoPin, HIGH);
long distancia = duracion * 0.034 / 2;
return distancia;
}
void adelante() {
analogWrite(motorIzqA, velocidad);
analogWrite(motorIzqB, 0);
analogWrite(motorDerA, velocidad);
analogWrite(motorDerB, 0);
}
void retroceder() {
analogWrite(motorIzqA, 0);
analogWrite(motorIzqB, velocidad);
analogWrite(motorDerA, 0);
analogWrite(motorDerB, velocidad);
}
void girarDerecha() {
analogWrite(motorIzqA, velocidad);
analogWrite(motorIzqB, 0);
analogWrite(motorDerA, 0);
analogWrite(motorDerB, velocidad);
}
void detener() {
analogWrite(motorIzqA, 0);
analogWrite(motorIzqB, 0);
analogWrite(motorDerA, 0);
analogWrite(motorDerB, 0);
}
Controla tu robot desde tu smartphone usando el módulo Bluetooth HC-05 y apps como Arduino Bluetooth Controller.
// Motores
const int motorIzqA = 5;
const int motorIzqB = 6;
const int motorDerA = 9;
const int motorDerB = 10;
const int velocidad = 200;
char comando;
void setup() {
pinMode(motorIzqA, OUTPUT);
pinMode(motorIzqB, OUTPUT);
pinMode(motorDerA, OUTPUT);
pinMode(motorDerB, OUTPUT);
Serial.begin(9600); // Bluetooth
}
void loop() {
if (Serial.available() > 0) {
comando = Serial.read();
switch(comando) {
case 'F': // Forward
adelante();
break;
case 'B': // Back
retroceder();
break;
case 'L': // Left
girarIzquierda();
break;
case 'R': // Right
girarDerecha();
break;
case 'S': // Stop
detener();
break;
}
}
}
void adelante() {
analogWrite(motorIzqA, velocidad);
analogWrite(motorIzqB, 0);
analogWrite(motorDerA, velocidad);
analogWrite(motorDerB, 0);
}
void retroceder() {
analogWrite(motorIzqA, 0);
analogWrite(motorIzqB, velocidad);
analogWrite(motorDerA, 0);
analogWrite(motorDerB, velocidad);
}
void girarIzquierda() {
analogWrite(motorIzqA, 0);
analogWrite(motorIzqB, velocidad);
analogWrite(motorDerA, velocidad);
analogWrite(motorDerB, 0);
}
void girarDerecha() {
analogWrite(motorIzqA, velocidad);
analogWrite(motorIzqB, 0);
analogWrite(motorDerA, 0);
analogWrite(motorDerB, velocidad);
}
void detener() {
analogWrite(motorIzqA, 0);
analogWrite(motorIzqB, 0);
analogWrite(motorDerA, 0);
analogWrite(motorDerB, 0);
}
Crea animaciones, caras y mensajes en una matriz LED 8x8 usando el módulo MAX7219.
#include <LedControl.h>
// LedControl(DIN, CLK, CS, número de matrices)
LedControl lc = LedControl(12, 11, 10, 1);
// Cara feliz
byte caraFeliz[8] = {
B00111100,
B01000010,
B10100101,
B10000001,
B10100101,
B10011001,
B01000010,
B00111100
};
// Cara triste
byte caraTriste[8] = {
B00111100,
B01000010,
B10100101,
B10000001,
B10011001,
B10100101,
B01000010,
B00111100
};
// Corazón
byte corazon[8] = {
B00000000,
B01100110,
B11111111,
B11111111,
B11111111,
B01111110,
B00111100,
B00011000
};
void setup() {
lc.shutdown(0, false);
lc.setIntensity(0, 8); // Brillo (0-15)
lc.clearDisplay(0);
}
void loop() {
// Mostrar cara feliz
mostrarImagen(caraFeliz);
delay(2000);
// Mostrar corazón
mostrarImagen(corazon);
delay(2000);
// Mostrar cara triste
mostrarImagen(caraTriste);
delay(2000);
}
void mostrarImagen(byte imagen[]) {
for (int i = 0; i < 8; i++) {
lc.setRow(0, i, imagen[i]);
}
}
Proyecto avanzado que mide temperatura, humedad, presión atmosférica y calidad del aire. Los datos se muestran en un display LCD y pueden enviarse a la nube para monitoreo remoto.
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <DHT.h>
#include <Adafruit_BMP280.h>
#include <RTClib.h>
// Configuración de sensores
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
Adafruit_BMP280 bmp;
RTC_DS3231 rtc;
LiquidCrystal_I2C lcd(0x27, 16, 2);
const int MQ135_PIN = A0;
// Variables
float temperatura = 0;
float humedad = 0;
float presion = 0;
int calidadAire = 0;
unsigned long ultimaActualizacion = 0;
const long intervalo = 2000;
int pantallaActual = 0;
void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();
lcd.setCursor(0, 0);
lcd.print("Estacion Meteo");
lcd.setCursor(0, 1);
lcd.print("Iniciando...");
delay(2000);
dht.begin();
if (!bmp.begin(0x76)) {
Serial.println("Error BMP280");
lcd.clear();
lcd.print("Error BMP280");
while(1);
}
if (!rtc.begin()) {
Serial.println("Error RTC");
}
bmp.setSampling(Adafruit_BMP280::MODE_NORMAL,
Adafruit_BMP280::SAMPLING_X2,
Adafruit_BMP280::SAMPLING_X16,
Adafruit_BMP280::FILTER_X16,
Adafruit_BMP280::STANDBY_MS_500);
lcd.clear();
Serial.println("Sistema Iniciado");
}
void loop() {
unsigned long tiempoActual = millis();
if (tiempoActual - ultimaActualizacion >= intervalo) {
ultimaActualizacion = tiempoActual;
leerSensores();
mostrarEnLCD();
enviarDatosSerie();
if ((tiempoActual / 4000) % 3 != pantallaActual) {
pantallaActual = (tiempoActual / 4000) % 3;
}
}
}
void leerSensores() {
humedad = dht.readHumidity();
temperatura = dht.readTemperature();
presion = bmp.readPressure() / 100.0;
calidadAire = analogRead(MQ135_PIN);
if (isnan(humedad) || isnan(temperatura)) {
Serial.println("Error DHT22");
return;
}
}
void mostrarEnLCD() {
lcd.clear();
switch(pantallaActual) {
case 0:
lcd.setCursor(0, 0);
lcd.print("Temp: ");
lcd.print(temperatura, 1);
lcd.print((char)223);
lcd.print("C");
lcd.setCursor(0, 1);
lcd.print("Hum: ");
lcd.print(humedad, 1);
lcd.print("%");
break;
case 1:
lcd.setCursor(0, 0);
lcd.print("Presion:");
lcd.setCursor(0, 1);
lcd.print(presion, 1);
lcd.print(" hPa");
break;
case 2:
lcd.setCursor(0, 0);
lcd.print("Calidad Aire:");
lcd.setCursor(0, 1);
if (calidadAire < 300) {
lcd.print("Buena");
} else if (calidadAire < 500) {
lcd.print("Moderada");
} else {
lcd.print("Mala");
}
lcd.print(" (");
lcd.print(calidadAire);
lcd.print(")");
break;
}
}
void enviarDatosSerie() {
DateTime now = rtc.now();
Serial.print(now.year());
Serial.print("/");
Serial.print(now.month());
Serial.print("/");
Serial.print(now.day());
Serial.print(" ");
Serial.print(now.hour());
Serial.print(":");
Serial.print(now.minute());
Serial.print(" | Temp: ");
Serial.print(temperatura);
Serial.print("°C | Hum: ");
Serial.print(humedad);
Serial.print("% | Pres: ");
Serial.print(presion);
Serial.print(" hPa | Aire: ");
Serial.println(calidadAire);
}
Control preciso de un robot usando un joystick analógico. La velocidad y dirección se ajustan según la posición del joystick, permitiendo movimientos suaves y naturales.
// Pines del Joystick
const int joyX = A0;
const int joyY = A1;
const int joyButton = 7;
// Pines motores
const int motorIzqA = 5;
const int motorIzqB = 6;
const int enableIzq = 3;
const int motorDerA = 9;
const int motorDerB = 10;
const int enableDer = 11;
const int ledPin = 13;
int valorX = 0;
int valorY = 0;
int velocidadIzq = 0;
int velocidadDer = 0;
bool turboMode = false;
const int zonaMuerta = 50;
const int velocidadTurbo = 255;
const int velocidadNormal = 180;
void setup() {
pinMode(motorIzqA, OUTPUT);
pinMode(motorIzqB, OUTPUT);
pinMode(enableIzq, OUTPUT);
pinMode(motorDerA, OUTPUT);
pinMode(motorDerB, OUTPUT);
pinMode(enableDer, OUTPUT);
pinMode(joyButton, INPUT_PULLUP);
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
Serial.println("Robot Joystick Iniciado");
}
void loop() {
valorX = analogRead(joyX);
valorY = analogRead(joyY);
if (digitalRead(joyButton) == LOW) {
turboMode = !turboMode;
digitalWrite(ledPin, turboMode ? HIGH : LOW);
delay(300);
}
int x = map(valorX, 0, 1023, -255, 255);
int y = map(valorY, 0, 1023, -255, 255);
if (abs(x) < zonaMuerta) x = 0;
if (abs(y) < zonaMuerta) y = 0;
velocidadIzq = y + x;
velocidadDer = y - x;
int velMax = turboMode ? velocidadTurbo : velocidadNormal;
velocidadIzq = constrain(velocidadIzq, -velMax, velMax);
velocidadDer = constrain(velocidadDer, -velMax, velMax);
controlarMotor(motorIzqA, motorIzqB, enableIzq, velocidadIzq);
controlarMotor(motorDerA, motorDerB, enableDer, velocidadDer);
if (millis() % 500 < 50) {
Serial.print("X: ");
Serial.print(x);
Serial.print(" | Y: ");
Serial.print(y);
Serial.print(" | Izq: ");
Serial.print(velocidadIzq);
Serial.print(" | Der: ");
Serial.print(velocidadDer);
Serial.print(" | Turbo: ");
Serial.println(turboMode ? "ON" : "OFF");
}
delay(20);
}
void controlarMotor(int pinA, int pinB, int pinEnable, int velocidad) {
int velAbs = abs(velocidad);
if (velocidad > 0) {
digitalWrite(pinA, HIGH);
digitalWrite(pinB, LOW);
} else if (velocidad < 0) {
digitalWrite(pinA, LOW);
digitalWrite(pinB, HIGH);
} else {
digitalWrite(pinA, LOW);
digitalWrite(pinB, LOW);
}
analogWrite(pinEnable, velAbs);
}
Sistema completo de alarma con sensor de movimiento PIR, teclado matricial para código de acceso, buzzer para alertas y LED indicadores de estado.
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
const byte FILAS = 4;
const byte COLS = 4;
char teclas[FILAS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte pinesFilas[FILAS] = {9, 8, 7, 6};
byte pinesCols[COLS] = {5, 4, 3, 2};
Keypad teclado = Keypad(makeKeymap(teclas), pinesFilas, pinesCols, FILAS, COLS);
const int pirPin = 12;
const int buzzerPin = 11;
const int ledVerde = A0;
const int ledAmarillo = A1;
const int ledRojo = A2;
String codigoSecreto = "1234";
String codigoIngresado = "";
bool sistemaArmado = false;
bool alarmaActivada = false;
unsigned long tiempoDeteccion = 0;
const unsigned long tiempoGracia = 10000;
int intentosFallidos = 0;
const int maxIntentos = 3;
void setup() {
pinMode(pirPin, INPUT);
pinMode(buzzerPin, OUTPUT);
pinMode(ledVerde, OUTPUT);
pinMode(ledAmarillo, OUTPUT);
pinMode(ledRojo, OUTPUT);
lcd.init();
lcd.backlight();
Serial.begin(9600);
mostrarMensaje("Sistema Alarma", "Iniciando...", 2000);
mostrarMensaje("Ingrese codigo", "para armar", 0);
actualizarLEDs();
}
void loop() {
char tecla = teclado.getKey();
if (tecla) {
procesarTecla(tecla);
}
if (sistemaArmado && !alarmaActivada) {
if (digitalRead(pirPin) == HIGH) {
if (tiempoDeteccion == 0) {
tiempoDeteccion = millis();
mostrarMensaje("MOVIMIENTO", "DETECTADO!", 0);
parpadearLED(ledAmarillo, 3);
Serial.println("Movimiento detectado");
}
if (millis() - tiempoDeteccion > tiempoGracia) {
activarAlarma();
} else {
int segundosRestantes = (tiempoGracia - (millis() - tiempoDeteccion)) / 1000;
lcd.setCursor(0, 1);
lcd.print("Tiempo: ");
lcd.print(segundosRestantes);
lcd.print("s ");
}
}
}
if (alarmaActivada) {
sonarAlarma();
}
}
void procesarTecla(char tecla) {
if (tecla == '#') {
verificarCodigo();
} else if (tecla == '*') {
codigoIngresado = "";
if (!sistemaArmado) {
mostrarMensaje("Codigo borrado", "Ingrese codigo", 1000);
}
} else if (tecla >= '0' && tecla <= '9') {
if (codigoIngresado.length() < 4) {
codigoIngresado += tecla;
lcd.setCursor(codigoIngresado.length() - 1, 1);
lcd.print('*');
tone(buzzerPin, 1000, 50);
}
}
}
void verificarCodigo() {
if (codigoIngresado == codigoSecreto) {
intentosFallidos = 0;
if (!sistemaArmado) {
sistemaArmado = true;
alarmaActivada = false;
tiempoDeteccion = 0;
mostrarMensaje("SISTEMA ARMADO", "Proteccion ON", 2000);
parpadearLED(ledVerde, 3);
} else {
sistemaArmado = false;
alarmaActivada = false;
tiempoDeteccion = 0;
noTone(buzzerPin);
mostrarMensaje("DESARMADO", "Sistema OFF", 2000);
parpadearLED(ledVerde, 3);
mostrarMensaje("Ingrese codigo", "para armar", 0);
}
actualizarLEDs();
} else {
intentosFallidos++;
mostrarMensaje("CODIGO", "INCORRECTO", 2000);
parpadearLED(ledRojo, 3);
if (intentosFallidos >= maxIntentos && sistemaArmado) {
activarAlarma();
mostrarMensaje("DEMASIADOS", "INTENTOS!", 0);
} else if (sistemaArmado) {
mostrarMensaje("Movimiento", "detectado", 0);
} else {
mostrarMensaje("Ingrese codigo", "para armar", 0);
}
}
codigoIngresado = "";
}
void activarAlarma() {
alarmaActivada = true;
mostrarMensaje("!! ALARMA !!", "!! ACTIVADA !!", 0);
Serial.println("ALARMA ACTIVADA");
}
void sonarAlarma() {
for (int i = 0; i < 3; i++) {
tone(buzzerPin, 2000, 200);
digitalWrite(ledRojo, HIGH);
delay(200);
tone(buzzerPin, 1500, 200);
digitalWrite(ledRojo, LOW);
delay(200);
}
}
void actualizarLEDs() {
digitalWrite(ledVerde, sistemaArmado && !alarmaActivada ? HIGH : LOW);
digitalWrite(ledAmarillo, LOW);
digitalWrite(ledRojo, alarmaActivada ? HIGH : LOW);
}
void parpadearLED(int pin, int veces) {
for (int i = 0; i < veces; i++) {
digitalWrite(pin, HIGH);
delay(100);
digitalWrite(pin, LOW);
delay(100);
}
}
void mostrarMensaje(String linea1, String linea2, int duracion) {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(linea1);
lcd.setCursor(0, 1);
lcd.print(linea2);
if (duracion > 0) {
delay(duracion);
}
}
Aquí aparecerán todos los proyectos compartidos por la comunidad. ¡Sé el primero en publicar!