💪BRAZO ROBÓTICO CON ELETROIMÁN Y ARDUINO ROMEO

En este tutorial veremos un brazo robótico, armado con un electroimán, 2 servos, un arduino romeo y piezas del juego didáctico Supermec 5.

Un electroimán es un tipo de imán en el que el campo magnético es producido por una corriente eléctrica. Una corriente eléctrica que fluye en un cable crea un campo magnético alrededor del cable, debido a la ley de Ampere (vea el dibujo más arriba). Para concentrar el campo magnético, en un electroimán el cable se enrolla en una bobina con muchas vueltas de cable una al lado de la otra. El campo magnético de todas las vueltas del cable pasa a través del centro de la bobina, creando un fuerte campo magnético allí. Este electroimán puede absorber 1 kg de peso y aguantar. Es fácil de usar.

Tal vez pueda interesarte proyectos en arduino, pic, robótica, telecomunicaciones, suscribete en http://www.youtube.com/user/carlosvolt?sub_confirmation=1 mucho videos con código fuentes completos y diagramas

¿Donde conseguir el este electroiman ? Visita la página de LCSC

Especificaciones

Parámetro	Valor
Tensión de trabajo	DC 5V
Corriente de trabajo	400mA
Corriente de espera	200uA
Peso de la carga	1 KILOGRAMO

Pinout cable electroiman

Pinout	Color
5V	rojo
GND	Negro
No conectado	Blanco
Pin digital	Amarillo

Pin out SG90 Servo

Naranja–> Señal

Rojo–> Positivo

Marrón–> Negativo

Software

Paso 1. Copie el siguiente código en Arduio IDE y cárguelo en arduino.

#include <Servo.h>//Librería para el control de los servos
Servo ServoUno;
Servo ServoDos;
int val0=0;
int val1=0;
int var7=0;
int magneto=13;
int estado=0;
void setup() {
ServoUno.attach(6);//El servo será controlado a través del pin 6
ServoUno.write(0);//Posición inicial del servo(modificar de ser necesario)
ServoDos.attach(7);//El servo será controlado a través del pin 7
ServoDos.write(0);//Posición inicial del servo(modificar de ser necesario)
pinMode(magneto, OUTPUT);//Se confira el pin del control del electroiman como salida
Serial.begin(9600);//Velocidad del puesto serial
}
void loop() {
 var7 = analogRead(7);//Lectura del pin analógico 7 del arduino romeo, donde el arduino Romeo tiene conectado 5 pulsadores.
//Si el valor leido es menor o igual a 100
if(var7<=100){
Serial.println("arriba");
if(val0>0){
val0=val0-5;
Serial.println(val0);
ServoUno.write(val0);
delay(50);  
  }
}
//Si el valor leido es menor o igual a 350 y mayor o igual a 300
if(var7<=350&&var7>=300){
Serial.println("abajo");  
if(val0<180){
val0=val0+5;
Serial.println(val0);
ServoUno.write(val0);
delay(100);
  }
}
//Si el valor leido es menor o igual a 200 y mayor o igual a 120
if(var7<=200&&var7>=120){
Serial.println("derecha");
if(val1<180){
val1=val1+5;
Serial.println(val1);
ServoDos.write(val1);
delay(50);
  }
//Si el valor leido es menor o igual a 550 y mayor o igual a 450  
  }
  Serial.println(val1);
if(var7<=550&&var7>=450){
Serial.println("izquierda");
if(val1>0){
val1=val1-5;
Serial.println(val1);
ServoDos.write(val1);
delay(50);
  } 
}
//---------------------
//Enciende o apaga el electroiman 
//Si el valor leido es menor o igual a 800 y mayor o igual a 650
if (var7<=800&&var7>=650) {
var7 = analogRead(7);//Leemos el estado del botón nuevamente, lo asignamos a var7
if(estado ==0){//Si la variable estado es igual a 0 se cumple esta condición
Serial.print("Electroimán activado");
digitalWrite(magneto, HIGH);
estado =1;//Asignamos el valor 1 a la variable "estado"
} else{
 Serial.print("Electroimán desactivado");
 digitalWrite(magneto, LOW);
 estado =0;//Asignamos el valor 0 a la variable "estado"
  }
//Si el valor leido es menor o igual a 800 y mayor o igual a 650
while(var7<=800&&var7>=650){
var7 = analogRead(7);//Se cumple esta condición mientras esté precionado el botón   
    }
  }
}

#include <Servo.h>//Librería para el control de los servos

Servo ServoUno;

Servo ServoDos;

int val0=0;

int val1=0;

int var7=0;

int magneto=13;

int estado=0;

void setup() {

ServoUno.attach(6);//El servo será controlado a través del pin 6

ServoUno.write(0);//Posición inicial del servo(modificar de ser necesario)

ServoDos.attach(7);//El servo será controlado a través del pin 7

ServoDos.write(0);//Posición inicial del servo(modificar de ser necesario)

pinMode(magneto, OUTPUT);//Se confira el pin del control del electroiman como salida

Serial.begin(9600);//Velocidad del puesto serial

}

void loop() {

var7 = analogRead(7);//Lectura del pin analógico 7 del arduino romeo, donde el arduino Romeo tiene conectado 5 pulsadores.

//Si el valor leido es menor o igual a 100

if(var7<=100){

Serial.println("arriba");

if(val0>0){

val0=val0-5;

Serial.println(val0);

ServoUno.write(val0);

delay(50);

}

//Si el valor leido es menor o igual a 350 y mayor o igual a 300

if(var7<=350&&var7>=300){

Serial.println("abajo");

if(val0<180){

val0=val0+5;

Serial.println(val0);

ServoUno.write(val0);

delay(100);

}

//Si el valor leido es menor o igual a 200 y mayor o igual a 120

if(var7<=200&&var7>=120){

Serial.println("derecha");

if(val1<180){

val1=val1+5;

Serial.println(val1);

ServoDos.write(val1);

delay(50);

}

//Si el valor leido es menor o igual a 550 y mayor o igual a 450

}

Serial.println(val1);

if(var7<=550&&var7>=450){

Serial.println("izquierda");

if(val1>0){

val1=val1-5;

Serial.println(val1);

ServoDos.write(val1);

delay(50);

}

//---------------------

//Enciende o apaga el electroiman

//Si el valor leido es menor o igual a 800 y mayor o igual a 650

if (var7<=800&&var7>=650) {

var7 = analogRead(7);//Leemos el estado del botón nuevamente, lo asignamos a var7

if(estado ==0){//Si la variable estado es igual a 0 se cumple esta condición

Serial.print("Electroimán activado");

digitalWrite(magneto, HIGH);

estado =1;//Asignamos el valor 1 a la variable "estado"

} else{

Serial.print("Electroimán desactivado");

digitalWrite(magneto, LOW);

estado =0;//Asignamos el valor 0 a la variable "estado"

}

//Si el valor leido es menor o igual a 800 y mayor o igual a 650

while(var7<=800&&var7>=650){

var7 = analogRead(7);//Se cumple esta condición mientras esté precionado el botón

}

SuperMec 5

¿Que es Arduino Romeo?

La familia Romeo es un placa de control de robotica Todo-En-Uno, especialmente diseñado para aplicaciones de robótica de DFRobot. Se beneficia de la plataforma de código abierto Arduino , es compatible con miles de códigos y puede ampliarse fácilmente con los escudos de Arduino. El controlador del motor CC de 2 vías integrado y el zócalo inalámbrico le permiten iniciar su propio proyecto de robotica inmediatamente sin la necesidad de un driver de motor adicional. No solo tiene el controlador del motor, Romeo también está diseñado para tener potencia extra para los servos que necesitan más corriente.

Romeo también se presenta con el estándar 3 Pin-out de DFRobot diseñado y compatible con los sensores y actuadores de la serie Gravity . Cientos de sensores ahora son plug-play con Romeo.

El primer miembro de la familia Romeo nació en 2009. No es solo el primer controlador de robot Arduino, sino también el primer tablero derivado de Arduino en el mercado. La versión actual de Romeo se basa en Arduino Uno. Ha incorporado 2 controladores de motor CC de 2 Amperes y zócalo para módulos de comunicación por radio Bluetooth /APC220 . El pin integrado del sensor entrada/salida le permite conectar cientos de diferentes sensores y módulos compatibles con Gravity .Tiene un conector servo que es un plug & play. Es el controlador ideal para construir su propio robot .

ESPECIFICACIONES

Suministro de CC: alimentado por USB o externo de 7V ~ 12V DC
Salida de CC: 5V / 3.3V DC y salida de potencia externa
Microcontrolador: Atmega328
Cargador de arranque: Arduino Uno
Compatible con el mapeo de pin Arduino Uno
8 canales de E/S analógicas de 10 bits
interfaz USB
5 teclas de entradas
Detección automática / entrada de potencia de conmutación
Encabezado ICSP para la descarga directa del programa
Serial Interface TTL Level
Soporte de encabezado macho y hembra
Sockets integrados para el módulo RF APC220 y el módulo DF-Bluetooth
Tres juegos de patillas de interfaz I2C (dos cabezales de patillas de 90 °)
Driver de motor de dos vías con corriente máxima 2A
Placa enchapado en oro
Tamaño: 90x80x14mm (3,54 «x3.15» x0.55 «)
Peso: 60 gramos

RoMeo Pinout

Placa

La imagen de arriba muestra todas las líneas y conectores de E / S en el Romeo, que incluye:

Un terminal de entrada de potencia de motor regulado (6v a 12v)
Un Terminal de entrada de alimentación servo no regulada (se suministra regulada de 4 v a 7.2 v)
Un puente de selección de potencia de entrada Servo
Un encabezado de módulo de interfaz serie para el módulo APC220 / Bluetooth
Dos terminales de motor CC: maneja la corriente del motor hasta 2A, en cada terminal
Un puerto I2C / TWI – SDA, SCL, 5V, GND
Un puerto analógico con 8 entradas analógicas – La entrada analógica 7 estará ocupada al conectar al puente «A7»
Un puerto I / O de propósito general con 13 líneas de E / S – 4,5,6,7 se puede usar para controlar motores
Un botón de reinicio
Jumper para habilitar / deshabilitar el control del motor

Antes de empezar

Aplicando potencia

Este es uno de los pasos más importantes antes de usarl Romeo y comunicarse con su controlador host. DEBE asegurarse de que aplique energía al terminal de alimentación con la polaridad correcta. La polaridad invertida dañará al Romeo.

Energía desde el puerto USB: simplemente conecte el cable USB, y Romeo puede funcionar. Tenga en cuenta que el USB solo puede suministrar corriente de 500 mA. Debería ser capaz de cumplir con la mayoría de los requisitos para la aplicación de iluminación LED. Sin embargo, no es suficiente para alimentar motores de CC o servo.

Alimentación de la entrada de potencia del motor: Simplemente conecte el cable de tierra a la bornera con la etiqueta «GND», y luego conecte el cable positivo a la bornera con la etiqueta «VIN».

NOTA: la tensión de alimentación máxima no puede exceder 14V CC.

Software

RoMeo puede ser programado por el IDE de Arduino. Se puede descargar en Arduino.cc , seleccione «Arduino UNO» como hardware.

Servo Power Select Jumper

Como la mayoría de los servos utilizan más corriente que la fuente de alimentación USB puede suministrar. Se proporciona un terminal de alimentación para alimentar el servo individualmente. Esta opción puede habilitarse / deshabilitarse mediante el puente de selección Servo Power.

Cuando se aplica el Servo Power Select Jumper, el servo funciona con 5V internos.

Cuando el Servo Power Select Jumper no se aplica, el servo está alimentado por una fuente de alimentación externa.

El Romeo V1.3 utiliza un conmutador automático para la selección de la fuente de alimentación. Cuando se haya aplicado la fuente de alimentación externa, el servo se alimentará automáticamente mediante la alimentación externa en lugar de la energía del USB.

Jumper Pin de control del motor

La aplicación de los jumper de control del motor asignará el Pin 5,6,7,8 para el control del motor.

Al quitar los puentes se liberarán los pines anteriores, y el controlador del motor se desactivará.

Botones

RoMeo tiene 5 botones S1-S5 (Figura 2). S1-S5 usa la entrada analógica del pin 7,

«Mapa del Pin del botón»
Alfiler	Función
Pin analógico 7	Botón S1-S5

Fig2: botones de Romeo

Ejemplo de uso de botones 1-5

//

char msgs[5][15] = {
  "Right Key OK ", 
  "Up Key OK    ", 
  "Down Key OK  ", 
  "Left Key OK  ", 
  "Select Key OK" };
char start_msg[15] = {
  "Start loop "};                    
int  adc_key_val[5] ={
  30, 150, 360, 535, 760 };
int NUM_KEYS = 5;
int adc_key_in;
int key=-1;
int oldkey=-1;
void setup() { 
  pinMode(13, OUTPUT);  //we'll use the debug LED to output a heartbeat
  Serial.begin(9600);

  /* Print that we made it here */
  Serial.println(start_msg); 
}

void loop() 
{
  adc_key_in = analogRead(7);    // read the value from the sensor  
  digitalWrite(13, HIGH);
  /* get the key */
  key = get_key(adc_key_in);    // convert into key press
  if (key != oldkey) {   // if keypress is detected
    delay(50);      // wait for debounce time
    adc_key_in = analogRead(7);    // read the value from the sensor  
    key = get_key(adc_key_in);    // convert into key press
    if (key != oldkey) {         
      oldkey = key;
      if (key >=0){
        Serial.println(adc_key_in, DEC);
        Serial.println(msgs[key]);
      }
    }
  }
  digitalWrite(13, LOW);
}
// Convert ADC value to key number
int get_key(unsigned int input)
{   
  int k;
  for (k = 0; k < NUM_KEYS; k++)
  {
    if (input < adc_key_val[k])
    {  
      return k;  
    }
  }
  if (k >= NUM_KEYS)
    k = -1;     // No valid key pressed
  return k;
}

char msgs[5][15] = {

"Right Key OK ",

"Up Key OK ",

"Down Key OK ",

"Left Key OK ",

"Select Key OK" };

char start_msg[15] = {

"Start loop "};

int adc_key_val[5] ={

30, 150, 360, 535, 760 };

int NUM_KEYS = 5;

int adc_key_in;

int key=-1;

int oldkey=-1;

void setup() {

pinMode(13, OUTPUT); //we'll use the debug LED to output a heartbeat

Serial.begin(9600);

/* Print that we made it here */

Serial.println(start_msg);

}

void loop()

{

adc_key_in = analogRead(7); // read the value from the sensor

digitalWrite(13, HIGH);

/* get the key */

key = get_key(adc_key_in); // convert into key press

if (key != oldkey) { // if keypress is detected

delay(50); // wait for debounce time

adc_key_in = analogRead(7); // read the value from the sensor

key = get_key(adc_key_in); // convert into key press

if (key != oldkey) {

oldkey = key;

if (key >=0){

Serial.println(adc_key_in, DEC);

Serial.println(msgs[key]);

}

digitalWrite(13, LOW);

}

// Convert ADC value to key number

int get_key(unsigned int input)

{

int k;

for (k = 0; k < NUM_KEYS; k++)

{

if (input < adc_key_val[k])

{

return k;

}

if (k >= NUM_KEYS)

k = -1; // No valid key pressed

return k;

}

Control de velocidad de motor doble de CC

Configuración de hardware

Conecte los cuatro cables del motor al terminal del motor de Romeo. Y aplique energía a través del terminal de potencia del motor (Figura 4).

Fig4: Diagrama de conexión de motor de Romeo

Asignación de pines

«Modo PWM»
PIN	Función
Digital 4	Motor 1 Control de dirección
Digital 5	Motor 1 control PWM
Digital 6	Motor 2 PWM control
Digital 7	Motor 2 Control de dirección

«Modo PLL»
Pin	Función
Digital 4	Motor 1 Habilitar control
Digital 5	Motor 1 Control de dirección
Digital 6	Motor 2 Control de dirección
Digital 7	Motor 2 Habilitar control

Modo de control PWM

Fig4: Asignación de clavijas de control del motor PWM

El control del motor PWM CC se implementa mediante la manipulación de dos pines E/S digitales y dos pines PWM. Como se ilustra en el diagrama de arriba (Figura 5), el Pin 4,7 (7,8 para la versión antigua de Romeo) son pasadores de control de la dirección del motor, Pin 5,6 (6,9 para la versión antigua de Romeo) son pasadores de control de velocidad del motor.

Para la placa Romeo anterior, los pines utilizados para controlar el motor son Pin 7,8 (Dirección), Pin 6,9 (Velocidad). Puede encontrar la información en el lado derecho de los puentes de control del motor.

Código de ejemplo:

//Standard PWM DC control
int E1 = 5;     //M1 Speed Control
int E2 = 6;     //M2 Speed Control
int M1 = 4;    //M1 Direction Control
int M2 = 7;    //M1 Direction Control

///For previous Romeo, please use these pins.
//int E1 = 6;     //M1 Speed Control
//int E2 = 9;     //M2 Speed Control
//int M1 = 7;    //M1 Direction Control
//int M2 = 8;    //M1 Direction Control


void stop(void)                    //Stop
{
  digitalWrite(E1,LOW);   
  digitalWrite(E2,LOW);      
}   
void advance(char a,char b)          //Move forward
{
  analogWrite (E1,a);      //PWM Speed Control
  digitalWrite(M1,HIGH);    
  analogWrite (E2,b);    
  digitalWrite(M2,HIGH);
}  
void back_off (char a,char b)          //Move backward
{
  analogWrite (E1,a);
  digitalWrite(M1,LOW);   
  analogWrite (E2,b);    
  digitalWrite(M2,LOW);
}
void turn_L (char a,char b)             //Turn Left
{
  analogWrite (E1,a);
  digitalWrite(M1,LOW);    
  analogWrite (E2,b);    
  digitalWrite(M2,HIGH);
}
void turn_R (char a,char b)             //Turn Right
{
  analogWrite (E1,a);
  digitalWrite(M1,HIGH);    
  analogWrite (E2,b);    
  digitalWrite(M2,LOW);
}
void setup(void) 
{ 
  int i;
  for(i=4;i<=7;i++)
    pinMode(i, OUTPUT);  
  Serial.begin(19200);      //Set Baud Rate
  Serial.println("Run keyboard control");
} 
void loop(void) 
{
  if(Serial.available()){
    char val = Serial.read();
    if(val != -1)
    {
      switch(val)
      {
      case 'w'://Move Forward
        advance (255,255);   //move forward in max speed
        break;
      case 's'://Move Backward
        back_off (255,255);   //move back in max speed
        break;
      case 'a'://Turn Left
        turn_L (100,100);
        break;       
      case 'd'://Turn Right
        turn_R (100,100);
        break;
      case 'z':
        Serial.println("Hello");
        break;
      case 'x':
        stop();
        break;
      }
    }
    else stop();  
  }
}

//Standard PWM DC control

int E1 = 5; //M1 Speed Control

int E2 = 6; //M2 Speed Control

int M1 = 4; //M1 Direction Control

int M2 = 7; //M1 Direction Control

///For previous Romeo, please use these pins.

//int E1 = 6; //M1 Speed Control

//int E2 = 9; //M2 Speed Control

//int M1 = 7; //M1 Direction Control

//int M2 = 8; //M1 Direction Control

void stop(void) //Stop

{

digitalWrite(E1,LOW);

digitalWrite(E2,LOW);

}

void advance(char a,char b) //Move forward

{

analogWrite (E1,a); //PWM Speed Control

digitalWrite(M1,HIGH);

analogWrite (E2,b);

digitalWrite(M2,HIGH);

}

void back_off (char a,char b) //Move backward

{

analogWrite (E1,a);

digitalWrite(M1,LOW);

analogWrite (E2,b);

digitalWrite(M2,LOW);

}

void turn_L (char a,char b) //Turn Left

{

analogWrite (E1,a);

digitalWrite(M1,LOW);

analogWrite (E2,b);

digitalWrite(M2,HIGH);

}

void turn_R (char a,char b) //Turn Right

{

analogWrite (E1,a);

digitalWrite(M1,HIGH);

analogWrite (E2,b);

digitalWrite(M2,LOW);

}

void setup(void)

{

int i;

for(i=4;i<=7;i++)

pinMode(i, OUTPUT);

Serial.begin(19200); //Set Baud Rate

Serial.println("Run keyboard control");

}

void loop(void)

{

if(Serial.available()){

char val = Serial.read();

if(val != -1)

{

switch(val)

{

case 'w'://Move Forward

advance (255,255); //move forward in max speed

break;

case 's'://Move Backward

back_off (255,255); //move back in max speed

break;

case 'a'://Turn Left

turn_L (100,100);

break;

case 'd'://Turn Right

turn_R (100,100);

break;

case 'z':

Serial.println("Hello");

break;

case 'x':

stop();

break;

}

else stop();

}

Modo de control PLL

Romeo también es compatible con oscilador enganchado en fase (PLL)

Fig5: Configuración de asignación de patillas de control del motor PLL

Código de muestra:

//Standard DLL Speed control

int E1 = 4;     //M1 Speed Control
int E2 = 7;     //M2 Speed Control
int M1 = 5;    //M1 Direction Control
int M2 = 6;    //M1 Direction Control

///For previous Romeo, please use these pins.
//int E1 = 6;     //M1 Speed Control
//int E2 = 9;     //M2 Speed Control
//int M1 = 7;    //M1 Direction Control
//int M2 = 8;    //M1 Direction Control

//When m1p/m2p is 127, it stops the motor
//when m1p/m2p is 255, it gives the maximum speed for one direction
//When m1p/m2p is 0, it gives the maximum speed for reverse direction

void DriveMotorP(byte m1p, byte m2p)//Drive Motor Power Mode
{

  digitalWrite(E1, HIGH);
  analogWrite(M1, (m1p)); 

  digitalWrite(E2, HIGH);
  analogWrite(M2, (m2p)); 

}

void setup(void) 
{ 
  int i;
  for(i=6;i<=9;i++)
    pinMode(i, OUTPUT);  
  Serial.begin(19200);      //Set Baud Rate
} 
void loop(void) 
{ 
  if(Serial.available()){
    char val = Serial.read();
    if(val!=-1)
    {
      switch(val)
      {
      case 'w'://Move Forward
        DriveMotorP(0xff,0xff); // Max speed
        break;
      case 'x'://Move Backward
        DriveMotorP(0x00,0x00);
        ; // Max speed
        break;
      case 's'://Stop
        DriveMotorP(0x7f,0x7f);
        break;       

      }
    }
  }
}

//Standard DLL Speed control

int E1 = 4; //M1 Speed Control

int E2 = 7; //M2 Speed Control

int M1 = 5; //M1 Direction Control

int M2 = 6; //M1 Direction Control

///For previous Romeo, please use these pins.

//int E1 = 6; //M1 Speed Control

//int E2 = 9; //M2 Speed Control

//int M1 = 7; //M1 Direction Control

//int M2 = 8; //M1 Direction Control

//When m1p/m2p is 127, it stops the motor

//when m1p/m2p is 255, it gives the maximum speed for one direction

//When m1p/m2p is 0, it gives the maximum speed for reverse direction

void DriveMotorP(byte m1p, byte m2p)//Drive Motor Power Mode

{

digitalWrite(E1, HIGH);

analogWrite(M1, (m1p));

digitalWrite(E2, HIGH);

analogWrite(M2, (m2p));

}

void setup(void)

{

int i;

for(i=6;i<=9;i++)

pinMode(i, OUTPUT);

Serial.begin(19200); //Set Baud Rate

}

void loop(void)

{

if(Serial.available()){

char val = Serial.read();

if(val!=-1)

{

switch(val)

{

case 'w'://Move Forward

DriveMotorP(0xff,0xff); // Max speed

break;

case 'x'://Move Backward

DriveMotorP(0x00,0x00);

; // Max speed

break;

case 's'://Stop

DriveMotorP(0x7f,0x7f);

break;

}

SUSCRIBETE A NUESTROS BOLETINES, RECIBE EN TU CORREO LAS NOTICIAS MÁS DESTACADAS, SÓLO INGRESANDO TU CORREO ELECTRÓNICO

[wysija_form id=”1″]

VIDEO RECOMENDADO

Diodos Semiconductores: la base de la electrónica moderna

🚀 Terravision: el mapa que Google borró de la historia (y el lema “No seas malo”)

SA828-V: Módulo Walkie Talkie VHF Todo en Uno – Potencia y Versatilidad en Tamaño Compacto

Comunicación Inalámbrica con nRF24L01+: Guía Completa para Integrarlo en tus Proyectos Electrónicos

Interrupt: La Amenaza Linux que Hará Temblar al Flipper Zero

Arduino Due: Potencia y Precisión para Proyectos Avanzados

RogerBit

"The Power Of The Bit"

💪BRAZO ROBÓTICO CON ELETROIMÁN Y ARDUINO ROMEO

Especificaciones

ESPECIFICACIONES

RoMeo Pinout

Antes de empezar

Aplicando potencia

Software

Servo Power Select Jumper

Jumper Pin de control del motor

Ejemplo de uso de botones 1-5

Control de velocidad de motor doble de CC

Configuración de hardware

Asignación de pines

Modo de control PWM

Deja una respuesta Cancelar la respuesta