TODOPIC
Mecatrónica => Robótica => Mensaje iniciado por: gab163 en 15 de Junio de 2013, 03:50:59
-
Hola a todos, soy estudiante de Maestría estoy en el área de sistemas de control y estoy desarrollando como proyecto un vehículo de dos ruedas autobalanceado tipo péndulo invertido. Estoy en el proceso de desarrollo ya he fabricado la estructura mecánica y estoy afinando detalles para la construcción de la parte electrónica les dejo las primera imágenes del carrito. Quien este interesado en hacer algo parecido puede preguntar y así ayudarnos a construirlo saludos. :-/
(http://mkmekatronika.files.wordpress.com/2013/06/seg.jpg)
(http://i83.servimg.com/u/f83/18/31/76/45/cables12.jpg)
-
Pues se ve muy bien, así que esperando ver como se desarrolla el proyecto.
-
Lindo trabajo! muy bien acabado ;) quedo atento para cuando subas mas detalles.
-
También estoy interesado, Actualmente estoy intentando hacer una INS/GPS.
Supongo que utilizaras sensores inerciales para saber su movimiento.
Saludos.
-
Así es PCCM estoy trabajando con acelerometros y giroscopios para saber la inclinación y el giro del carrito, para tener medido la velocidad y posición tengo unos encoders ópticos de 360 ppv y estoy ahorita con un circuito para monitorear la batería. Pues conforme avance estaré subiendo fotos y demás.
:-/
-
Así es PCCM estoy trabajando con acelerometros y giroscopios para saber la inclinación y el giro del carrito, para tener medido la velocidad y posición tengo unos encoders ópticos de 360 ppv y estoy ahorita con un circuito para monitorear la batería. Pues conforme avance estaré subiendo fotos y demás.
:-/
Hola.
Con respecto a la carcaza, lo que puedo ver en la foto esta armada con placas atornilladas. ¿Es asi, o es un bloque?. ¿De que espesor son las placas de alumino?
¿Podrias poner la denominacion de los elementos electronicos (acelerometro, giroscopos,etc) que estas utilizando?.¿Podrias indicar la denominacion (modelo) y/o caracteristicas electricas de los motores?.
¿Has probado cargando con peso lo que ya tenes desarrollado?
Te felicito. Muy bueno tu desarrollo. Voy a estar siguiendo tus avances.
Saludos.
-
Con respecto a la carcaza, lo que puedo ver en la foto esta armada con placas atornilladas. ¿Es asi, o es un bloque?. ¿De que espesor son las placas de alumino?
¿Podrias poner la denominacion de los elementos electronicos (acelerometro, giroscopos,etc) que estas utilizando?.¿Podrias indicar la denominacion (modelo) y/o caracteristicas electricas de los motores?.
¿Has probado cargando con peso lo que ya tenes desarrollado?
Darkman_A si son placas atornilladas maquinadas con CNC, el acelerometro que voy a utilizar es un LSM303DLHC que es acelerometro y brujula, para complementar a inclinación usare también un L3GD20 que es un gyro, para medir velocidad y desplazamiento usare un HEDS-5640 son encoders de 360ppv, los drivers son unos OSMC los motores no recuerdo los datos pero los estare subiendo.
Comenzare a hacer pruebas con los drivers el lunes de la semana que viene, ya que voy a salir de viaje pero llegando seguire con todo esto haber que sucede. Espero ya tener armado el circuito para esta semana que sigue es el plan. Este es el OSMC driver hasta 50V 160A va uno por cada motor.
-
Seguro utilizarás el acelerómetro para medir su inclinación y el giróscopio como complemento?, Si es así puedes plantear tu lógica.
Debido a que el sistema presentará aceleraciones lineales en el eje de desplazamiento y el mismo eje lo utilizarás para medir la inclinación, recomendaría que sea al revez, usar el giroscopio para medir la inclinación y utilizar el acelerómetro como sensor complementario para poder estimar el error debido a la deriva del giroscopio.
-
PCCM si tienes razón así es con lo del giroscopio y acelerometro,
Debido a que el sistema presentará aceleraciones lineales en el eje de desplazamiento y el mismo eje lo utilizarás para medir la inclinación
respecto a esto utilizare un modelo no lineal estoy viendo la manera de aplicar un controlador no lineal para obtener un mejor control que utilizando el sistema linealizado.
-
Una ves leí en una tesis que utilizaron lógica difusa para realizar un control a un sistema no lineal, los resultados fueron buenos.
-
respecto a esto utilizare un modelo no lineal estoy viendo la manera de aplicar un controlador no lineal para obtener un mejor control que utilizando el sistema linealizado.
Para los sistemas dinámicos pendulares he tenido éxito utilizando un control no lineal. El método analítico con mejores resultados (hasta el momento) para este tipo de planta ha sido el método de linealización exacta, creo que podría ser una buena opción de control para tu proyecto.
-
felicidades, muy buena pinta el proyecto.
mi pregunta en el espacio que te queda, podrás poner toda la electrónica?
como harás para que el vehículo gire? parece que el soporte(palo) esta fijo?
seguiré este proyecto. ((:-)) ((:-)) ((:-))
-
Una ves leí en una tesis que utilizaron lógica difusa para realizar un control a un sistema no lineal, los resultados fueron buenos.
Así es en estos momentos tengo en simulación un controlador difuso Takagui-sugeno, seria cuestio de probar controlador real una vez armado el circuito, tambien estoy viendo una retro linealizante para ver como se comporta.
Para los sistemas dinámicos pendulares he tenido éxito utilizando un control no lineal. El método analítico con mejores resultados (hasta el momento) para este tipo de planta ha sido el método de linealización exacta, creo que podría ser una buena opción de control para tu proyecto.
Lo tomare en cuenta gracias.
felicidades, muy buena pinta el proyecto.
mi pregunta en el espacio que te queda, podrás poner toda la electrónica?
como harás para que el vehículo gire? parece que el soporte(palo) esta fijo?
En el espacio que queda efectivamente pondré la electrónica y sobre el manubrio es fijo estoy por definir si usar unos puños de motocicleta para las vueltas ya que trae potenciometros o unos simples botones, lo primero que quiero es que se estabilice ya poco a poco iré afinando detalles.
-
Con respecto a la carcaza, lo que puedo ver en la foto esta armada con placas atornilladas. ¿Es asi, o es un bloque?. ¿De que espesor son las placas de alumino?
¿Podrias poner la denominacion de los elementos electronicos (acelerometro, giroscopos,etc) que estas utilizando?.¿Podrias indicar la denominacion (modelo) y/o caracteristicas electricas de los motores?.
¿Has probado cargando con peso lo que ya tenes desarrollado?
Darkman_A si son placas atornilladas maquinadas con CNC, el acelerometro que voy a utilizar es un LSM303DLHC que es acelerometro y brujula, para complementar a inclinación usare también un L3GD20 que es un gyro, para medir velocidad y desplazamiento usare un HEDS-5640 son encoders de 360ppv, los drivers son unos OSMC los motores no recuerdo los datos pero los estare subiendo.
Comenzare a hacer pruebas con los drivers el lunes de la semana que viene, ya que voy a salir de viaje pero llegando seguire con todo esto haber que sucede. Espero ya tener armado el circuito para esta semana que sigue es el plan. Este es el OSMC driver hasta 50V 160A va uno por cada motor.
Hola gab163.
Gracias por tomarte la molestia de responder mi consulta y en forma tan detallada. Recien hoy me percate de la misma.
Sigo atento tu desarrollo.
Saludos.
-
No había tenido tiempo de subir la prueba de los drivers con los motores voy de poco a poco, pues parece ser que todo va bien los MOSFETS del driver no se calientan ni tantito trate de frenarlos con la mano para simular una carga mas fuerte pero por la caja de engranes pues es casi imposible necesitare subirme para probarlos pero creo que no tendrá ningún problema. Hice pruebas para encontrar la zona muerta y checar cambio de dirección y de velocidad. Seguiré subiendo conforme avance me enfocare a armar la tarjeta en estos días y cuando tenga algo en concreto lo subo. :-/
-
Antes que nada quiero felicitarte por la tarea emprendida se ve muy bien el proyecto seguiré el desarrollo del mismo.
-
Los japoneses siguen sacando nuevos producto el año pasado vi Honda U3-X.
-
Bueno siguiendo con el proyecto acá les dejo unas imágenes de la tarjeta de control, se basa en un PIC16f1939 corriendo a 32MHz que se encarga de monitorear los sensores: gyro, acelerometro y encoders. Un dspic30f3010 a 30MIPS el cual estará leyendo los datos del 1939 por medio de la UART con los cuales calculara la ley de control y la sacara por medio del modulo de control de motores el cual lo configure a un periodo 5Khz el cual sale por medio de optoacopladores hacia los drivers OSMC les dejo el primer prototipo estare probando todo en conjunto antes de montarle los drivers y los motores
-
Muy padre tu proyecto.
El pcb se ve genial!! 8)
Felicitaciones!! y esperamos mas detalles !! ((:-)) ((:-)) ((:-))
-
Los japoneses siguen sacando nuevos producto el año pasado vi Honda U3-X.
Estas dos chicas me hicieron acordar a la pelicula Wall-e, si se populariza este aparatito o similares, en poco tiempo van a tener que hacerlos un poco mas resistentes para soportar los excesos de pesos de las personas.
Bueno siguiendo con el proyecto acá les dejo unas imágenes de la tarjeta de control, se basa en un PIC16f1939 corriendo a 32MHz que se encarga de monitorear los sensores: gyro, acelerometro y encoders. Un dspic30f3010 a 30MIPS el cual estará leyendo los datos del 1939 por medio de la UART con los cuales calculara la ley de control y la sacara por medio del modulo de control de motores el cual lo configure a un periodo 5Khz el cual sale por medio de optoacopladores hacia los drivers OSMC les dejo el primer prototipo estare probando todo en conjunto antes de montarle los drivers y los motores
Muy linda la placa, segui para adelante con el proyecto que es muy desafiante ;-)
-
Siguiendo con este cacharrito les comento que ya tengo lectura del ángulo usando el acelerometro en conjunto del gyro los sensores LSM303DLHC y L3GD20 respectivamente, realize una libreria para hacer las lecturas del eje que en mi caso como acomode la pcb es el eje Y les dejo la libreria por si alguien se anima a usarla y si se puede mejorarla pues sera mejor, el codigo es para CCS yo estoy usando el PIC16f1939 pero se puede ajustar a cualquiera. Las resistencias pull-up para el bus de i2c las tengo de 4.7Kohms.
Para usarla unicamente se llama a la función leer_angulo(); dando como argumento el tiempo de muestreo en ms
void main(){
float angulo;
int ts=20;
gyro_init(); //inicialización de gyro
accel_init(); //inicialización de acel
while(1){
angulo=leer_angulo(ts);
delay_ms(ts);
}
}
Aquí la librería IMU.h:
/*********************************************
Libreria para leer IMU
Acelerometro y Magnetometro LSM303DHLHC
Giroscopio L3GD20
Ing. Gabriel Casarrubias Guerrero
*********************************************/
#use i2c(Master, sda=PIN_C4, scl=PIN_C3)
#include <MATH.h>
float olda=0; //angulo en el instante anterior
//****************** Registros de configuración de acelerometro
#define escriacce 0x32 //dirección de escritura para acelerometro
#define lectacce 0x33 //dirección de lectura para acelerometro
#define REG1_A 0x20 //registro de configuración 1
#define REG2_A 0x21 //registro de configuración 2
#define REG3_A 0X22 //registro de configuración 3
#define REG4_A 0X23 //registro de configuración 4
#define REG5_A 0X24 //registro de configuración 5
#define REG6_A 0X25 //registro de configuración 6
//***************** Registros de configuración de magnetometro
#define magneton 0x3c //dirección de magnetometro
#define LSM303_MR_REG_M 0x02
//******************* Registros de configuración de gyro
#define escrigiro 0xD6 //Dirección de escritura para giro
#define lectgiro 0xD7 //Dirección de lectura para giro
#define REG1_G 0x20 //registro de configuración 1
#define REG2_G 0x21 //registro de configuración 2
#define REG3_G 0X22 //registro de configuración 3
#define REG4_G 0X23 //registro de configuración 4
#define REG5_G 0X24 //registro de configuración 5
//******************* Registros de lectura para IMU acelerometro y gyro
#define OUT_X_L 0x28
#define OUT_X_H 0x29
#define OUT_Y_L 0x2A
#define OUT_Y_H 0x2B
#define OUT_Z_L 0x2C
#define OUT_Z_H 0x2D
//******************************************************************************
//**********Función para escribir un dato a los sensores************************
// dirección=dirección del dispositivo
// reg= registro al cual se escribe
// valor= valor que se escribira
void escribir_dato(int direccion,int reg, int valor){
i2c_start();
i2c_write(direccion);
i2c_write(reg);
i2c_write(valor);
i2c_stop();
}
//******************** funciones manejo de acelerometro*************************
//funcion que inicializa el accelerometro;
void accel_init(){
escribir_dato(escriacce,REG1_A,0b01100111); //modo normal a 200Hz
escribir_dato(escriacce,REG2_A,0);
escribir_dato(escriacce,REG3_A,0);
escribir_dato(escriacce,REG4_A,0b00001001);//actualización continua, justificado a la izquierda, rango de +-2g,high resolution
escribir_dato(escriacce,REG5_A,0);
escribir_dato(escriacce,REG6_A,0);
}
//funcion para leer el dato del accelerometro
// reg= registro bajo que se leera
int16 leer_accel(int8 reg){
int16 dato;
int Al,Ah;
i2c_start();
i2c_write(escriacce);
i2c_write(reg);
i2c_start();
i2c_write(lectacce);
Al=i2c_read(0);
i2c_stop();
//lectura registro alto
i2c_start();
i2c_write(escriacce);
i2c_write(reg+1);
i2c_start();
i2c_write(lectacce);
Ah=i2c_read(0);
i2c_stop();
dato=Ah;
dato=dato<<8; // Ah:Al
dato=dato+Al; //dato de la forma AD:C0 donde el valor es AD:C y los primeeros 4 bits no cuentan
//entonces se recorre el dato a la derecha 4 bits.
dato=dato>>4;
return(dato); //dato leido del acelerometro
}
//********funcion para convertir el dato del accelerometro a g
// dato= dato que se convertira
float convertirg(int16 dato){
float salida;
salida=(float)dato;
salida=salida*.001; //resolucíon en +-2g=1mg/LSB
if(salida>=3.0) //condición para detectar los negativos
salida=-(4.1-salida);
return(salida);
}
// funcion para convertir de g a grados
// dato= dato a convertir
float caccelgrados(float dato){
float grados;
grados=asin(dato)*180/3.14158; //dato=g*sen(Theta) radianes para grados se multiplica por 180/pi
return(grados);
}
//funcion para convertir de g a radianes
// dato=dato a convertir
float caccelradianes(float dato){
float grados;
grados=asin(dato);
return(grados);
}
//******************* funciones manejo de gyroscopio***************************
// función para inicializar el gyro
void gyro_init(){
escribir_dato(escrigiro,REG1_G,0b10101111);
//escribir_dato(escrigiro,REG2_G,0b00000000);
//escribir_dato(escrigiro,REG3_G,0b00000000);
escribir_dato(escrigiro,REG4_G,0b00000001);
escribir_dato(escrigiro,REG5_G,0);
}
//función para leer el dato del giro
// reg= registro parte baja que se leera
int16 leer_gyro(int8 reg){
int16 dato;
int Al,Ah;
i2c_start();
i2c_write(escrigiro);
i2c_write(reg);
i2c_start();
i2c_write(lectgiro);
Al=i2c_read(0);
i2c_stop();
//lectura de registro parte alta
i2c_start();
i2c_write(escrigiro);
i2c_write(reg+1);
i2c_start();
i2c_write(lectgiro);
Ah=i2c_read(0);
i2c_stop();
dato=Ah;
dato=dato<<8;
dato=dato+Al;
dato=dato>>4;
//printf(lcd_putc,"\f Ah: %d+%d",Ah,Al);
return(dato);
}
//funcion para convertir a grados por segundo el dato del gyro
// dato=dato a convertir
float convertirdps(int16 dato){
float salida;
salida=(float)dato;
salida=salida*0.00875; //resolucion en 250dps=8.75mdps/LSB
return(salida);
}
//función que conjunta las mediciones para obtener una lectura corregida
// dato = dato en dps del gyro
// old= ángulo en un instante anterior
// tm= tiempo de muestreo
// Aacc= angulo del acelerometro
float cgyrogrados(float dato,float old,int tm,float Aacc){
float angulo;
float a=0.8;
angulo=((old+(dato*tm/1000))*a+(Aacc*(1-a)));// ángulo=(old+dato*ts)*a+Aacc*(1-a);
//donde a es el grado de confiabilidad del gyro con respecto al acelerometro dependiendo lo observado.
return(angulo);
}
//funcion que tenemos que llamar para leer el angulo en el eje Y para leer otro cambiar OUT_Y_L por OUT_X_L u OUT_Z_L
//tm= tiempo de muestreo para hacer la correción
float leer_angulo(int tm){
float Ya,Yg,Aya,Ayg;
int16 Yda,Ydg;
Yda=leer_accel(OUT_Y_L); //lee el dato del acelerometro
Ydg=leer_gyro(OUT_Y_L); //lee el dato del gyro
Ya=convertirg(Yda); //convierte a g el dato del acelerometro
Yg=convertirdps(Ydg); //convierte a º/s el dato del gyro
Aya=caccelgrados(Ya); //convierte a º las g
Ayg=cgyrogrados(Yg,olda,tm,Aya); //convierte a º las dps corrigiendo con el angulo del accelerometro
olda=Ayg; //actualiza el instante anterior
return(Ayg);
}
-
Interesante algoritmo:
angulo=((old+(dato*tm/1000))*a+(Aacc*(1-a)));
Tengo algunas dudas:
- Tu giroscopio no tiene offset para corregir?.
- Cuanto demora en converger tu angulo(ante movimientos rápidos de cabeceo en tu aplicación)?
- con tu "a" de 0.8 no estas dependiendo mucho del acelerómetro, has hecho pruebas con tu carrito en movimiento o solo estaticamente girando?, ya que con ese valor de "a" el acelerometro aporta 1/5 de angulo en la corrección cada 20 ms, si acelera en linea recta sin cabecear solo en un pequeño instante(una muestra) el acel dará aprox supongamos 40 grados, lo cual aportará 40/5=8 grados el cual debería ser 0, ello no afecta en tu control?.
-
Hola PCCM apenas termine el código esta mañana por lo cual no me ha dado tiempo de probar en movimiento en cuanto tenga mas avances los mostrare para ver si puedo responder tus preguntas, saludos
-
¡Hola PCCM! En esta página encontraras más información de este algoritmo:
http://web.mit.edu/scolton/www/filter.pdf (http://web.mit.edu/scolton/www/filter.pdf)
Es mucho más simple que el filtro Kalman.
Saludos,
Miquel
-
Se llama filtro complementario. Es un caso específico del filtro de Kalman. Hay mucha información en internet, pueden buscar en google como "complementary filter" ;)
Básicamente lo que hace es tomar las componentes de alta frecuencia del gyro, y las fusiona con las componentes de baja frecuencia del acelerómetro.
Saludos!!
-
Bueno he decidido usar el filtro de Kalman ya que es lo que nos enseñan y aparte de que mi compañero ya trabajo en esta parte por lo cual solo tuve que modificar algunas cosas pero es su libreria he aquí esta:
Como argumentos va primero la lectura del accelerometro en radianes y despues la del giroscopio en radianes/s, obtenemos el ángulo en radianes y para que funcione correctamente hay que modificar la Matriz Q y R y tambien depende del tiempo de muestro.
/*
*** Filtro de kalman
*** M.C. Jorge Bonales
********************************************************************************
*/
//**********************Variables que se actualizan*****************************
//Matrz de covarianza P
float P[2][2]={{100000,0},{0,100000}};
//matriz inicial de los estados
float x[2][2]={{0,0},{0,0}};
//Ganancia de Kalman
float K[2][1];
float Pn[2][2];
float Acel_K;
float gyro_ant;
int w=0;
//******************************************************************************
float k_filter(float acel_rad,float gyro_rad){
//Tiempo de muestreo en ms
const float Ts=.002;
//Matriz de covarianza del ruido
float Q[2][2]={{0.5,0},{0,0.5}};
//Varianza R
float R=.1;
//Matriz A de la forma A=[1,-Ts;0,1]
float A[2][2]={{1,-Ts},{0,1}};
//Matriz B=[Ts;0]
float B[2][1] ={{Ts},{0}};
//Matriz C
float C[1][2]={{1,0}};
//********************Etapa de predicción
if (w==0){
gyro_ant=gyro_rad;
w=1;
}
else{
//x(:,k)=A*x(:,k-1)+B*gyro_ant
x[0][1]=x[0][0]+A[0][1]*x[1][0]+B[0][0]*gyro_ant;
x[1][1]=A[1][1]*x[1][0];
Pn[0][0]=P[0][0]+A[0][1]*P[1][0]+(P[0][1]+A[0][1]*P[1][1])*A[0][1]+Q[0][0];
Pn[0][1]=P[0][1]+A[0][1]*P[1][1];
Pn[1][0]=Pn[0][1];
Pn[1][1]=P[1][1]+Q[1][1];
P[0][0]=Pn[0][0];
P[0][1]=Pn[0][1];
P[1][0]=Pn[1][0];
P[1][1]=Pn[1][1];
//*******************Etapa de corrección***********
// Actualización de la ganancia de Kalman
K[0][0]=P[0][0]/(P[0][0]+R);
K[1][0]=P[1][0]/(P[0][0]+R);
//Actualización del estado
x[0][0]=x[0][1]+K[0][0]*(acel_rad-x[0][1]);
x[1][0]=x[1][1]+K[1][0]*(acel_rad-x[0][1]);
//Actualización de la covarianza del error de estimación
Pn[0][0]=P[0][0]-K[0][0]*P[0][0];
Pn[0][1]=P[0][1]-K[0][0]*P[0][1];
Pn[1][0]=P[1][0]-K[1][0]*P[0][0];
Pn[1][1]=P[1][1]-K[1][0]*P[0][1];
P[0][0]=Pn[0][0];
P[0][1]=Pn[0][1];
P[1][0]=Pn[1][0];
P[1][1]=Pn[1][1];
}
//regresar el valor del acelerometro
Acel_K=x[0][0];
gyro_ant=gyro_rad;
return(Acel_K);
}
De igual manera estare armando las funciones para leer encoders y adc's para medir el nivel de baterias y la del calculo de la ley de control para poder ya probar todo en conjunto. en cuanto tenga algo lo subo.
-
Si, busqué lo del filtro complementario, como dice miguel y gera es una versión especifica del filtro kalman, además te consume mucho menos procesamiento que el de kalman. Sería interesante que pruebes los 2 algoritmos y muestres los resultados.
Tienes la ventaja de tener encoder para medir su aceleración aproximadamente en el mismo eje del acelerómetro.
Con ello puedes corregir la aceleración lineal que de dá el acelerómetro, ya que solo necesitas la aceleración de la gravedad.
O sino puedes hacer que tu covarianza de error en la medición(R) sea dinámica, osea a mayor aceleración captada por el encoder, aumentas el R para que la corrección no sea rápida.
-
Sería interesante que pruebes los 2 algoritmos y muestres los resultados.
Yo hice esa prueba (ademas pueden encontrarse varios papers con la comparacion). El filtro de kalman tiene una respuesta mucho mejor y es menos sensible a las vibraciones. Sin embargo, como vos decis, consume mas recursos computacionales y es dificil dejarlo bien "tuneado". En la mayoria de las aplicaciones, el filtro complementario cumple los objetivos ;)
Saludos!
-
Hola Muy bueno tu proyecto solo tengo una duda como conseguiste la OSMC, yo soy ciudadano colombiano y necesito una para un proyecto con motores te agradeceria pronta ayuda :-/
-
Pregunto aqui una duda que tengo por no abrir otro hilo,se podria hacer este robot con unos servos futaba,me gustaria intentarlo ya que tengo los sensores pero no quiero gastarme en motores ya que es paso previo a un quadcoptero y ahi me tendre que gastar en motores y demas
-
Pregunto aqui una duda que tengo por no abrir otro hilo,se podria hacer este robot con unos servos futaba,me gustaria intentarlo ya que tengo los sensores pero no quiero gastarme en motores ya que es paso previo a un quadcoptero y ahi me tendre que gastar en motores y demas
Sí, siempre y cuando te de el torque y velocidad de los motores para mantener equilibrado al robot (eso depende de las dimensiones y peso de tu robot). Vas a tener que modificar los servos para que puedan girar continuamente (http://www.instructables.com/id/How-to-modify-a-servo-motor-for-continuous-rotatio/)
Saludos!
-
Pregunto aqui una duda que tengo por no abrir otro hilo,se podria hacer este robot con unos servos futaba,me gustaria intentarlo ya que tengo los sensores pero no quiero gastarme en motores ya que es paso previo a un quadcoptero y ahi me tendre que gastar en motores y demas
efectivamente como dner en equilibrio el dice gera todo depende de la velocidad y torque para mantener el equilibrio del robot
-
Bueno les dejo las primeras pruebas con un simple PID, y filtro de KALMAN
ya va ,ya va. :mrgreen:
-
((:-)) ((:-)) se ve muy suave la respuesta de tu robot.
para el PID lo que hice fue ir incrementando la Kp hasta que empezara a oscilar y posteriormente la ki para suavizar la respuesta, el problema si subes mucho la ki es que el robot tarda mucho en quedarse quieto, que parece que es lo que le da esa pequeña oscilación al tuyo.
Otra cosa que puedes verificar es que tu punto de equilibrio coincida con el setpoint de tu controlador.
Creo que eso seria para hacer un poco mas rápida la estabilización de tu robot, pero me parece muy buena la respuesta que tiene, felicidades
-
Otra cosa que puedes verificar es que tu punto de equilibrio coincida con el setpoint de tu controlador.
respecto al setpoint pues el equilibrio es en cero de echo una vez que se equilibra si lo apago se queda equilibrado debido a que la manufactura se hizo con el proposito de mantener lo mas equilibrado el robot respecto a su propia masa, de las ganancias gracias por la sugerencia lo intentare haber que sucede.
Saludos
-
:-/ :-/ :-/
Wow!!
Que padre te esta quedando!! ((:-)) ((:-))
-
Bueno les comparto las primeras pruebas y accidentes de avance es difícil al comienzo controlarlo pero una vez que le hayas el modo pues es mas fácil. No había hecho las pruebas porque estaba documentando (mi tesis) pero ya comencé aun no le pongo los mandos de dirección pero en eso estoy poco a poco saludos.
-
¡Bravo!, qué gusto da verlo andando.
Pero ponte un casco hombre :D
-
Les comparto la prueba ya con los mandos de giro aun falta algunos detalles y poner los encoders para tenerlo listo :-/
-
Un genio tío!!!!!!!!!!!!!!!!! :-/
((:-)) ((:-)) ((:-)) ((:-)) ((:-)) ((:-)) ((:-))
-
excelente trabajo
parece que va bastante fino.
:-/ :-/ ((:-)) ((:-)) ((:-)) ((:-))
-
Hola a todos les comparto otro vídeo de una prueba con un controlador PD difuso mínimo con el cual el control del vehículo se hace mucho mas suave, les dejo la prueba de equilibro sin pasajero y espero mañana poder subir la prueba con piloto para mostrarles el resultado :-/
-
podrías poner el link del video? no veo el video incrustrado....
Saludos!
-
-
muy buenos los avance, gracias por compartirlos ((:-))
-
Una consulta, que potencia tienen los motores que estas utilizando?
Saludos!
-
Una consulta, que potencia tienen los motores que estas utilizando?
arriba de 25N.m