bueno bajo ese titulo se esconde algo simple:
tengo montado una especie de coche con 4 ruedas, dos traseras con motores independientes y dos delanteras sin traccion que lo unico que hacen es girar con un motor que hace las de volante.
lo que quiero montar y no consigo aclararme es con el sensor de rotacion, es leer los grados que estan giradas las ruedas y ponerlas rectas automaticamente.
supongo que seria algo asi como inicializando la posicion tope izquierda a 0, la posicion recta serian 45 y la tope derecha seran 90.
si al empezar el programa leo del sensor de rotacion 20, como es menor de 45 pues tendria que restar 45 - 20 = 25 y hacerlo girar en direccion Y. En caso de que sea mayor de 45 pues por ejemplo 60-45=15 y girar 15 en direccion -Y.
todo esto en cualquier lenguaje seria sencillisimo pero es que con esto de los cables y los simbolitos no me termino de aclarar jajaja
a ver si alguno sabe decirme como puedo hacerlo o guiarme un poco... que como me caliente le meto el firmware ese que deja programar en java y ala
Lo que yo haría (sin tener ni idea de como funciona el programejo :guino:) es primero girar las ruedas a la izquierda todo lo que puedan y leer el ángulo. Luego hacer lo propio hacia la derecha y leer el ángulo. Ya conocemos los topes, el centro estará a mitad de camino :guino: (aunque siempre habrá algún pequeño desvío... el autocentrado es un tema "delicado" :guino:)
En cuanto al leguaje de los simbolitos, ¿a cual te refieres? Yo del de LEGO pase a los 3 días.
No solo puedes programar en Java. ¿Has visto las demás opciones?
Yo no tengo de este programa, ni sé como hacerlo. Pero no sería más fácil poner el 0 en el centro, osea, con las ruedas centradas y una vez que acabe de realizarse un grio de x grados, radianes, etc, volver a la posición inicial, osea, el 0 centrao :guino:
Como ya he dicho no idea, pero eso me parece que es más sencilo de programar, que "vuelva al inicio" que no ponerlo en 45 o 60.
Además, se podría hacer una especie de error de cero y cada que vez que se inicase el programa se ajuste automaticamente?, al estar centrado sería fácil, creo. Esto es una idea, pero me gustó asique te la digo.
A ver si lo consigues :guino:
El problema, o al menos yo así lo entiendo, es como hacer que el bicho sepa él solito cual es el centro... una vez que lo sabe, el resto está hecho :guino: y le puedes llamar "como quieras" (obviamente lo más fácil es llamarle "0" pero si el lector te da una medida en esa posición habrá que trabajar con valores relativos, no absolutos)
la historia de esto es que no entiendo muy bien como funciona lo del reset del motor, porque haciendo una prueba que nada mas arrancar el programa lea la posición del motor y si es menor que cero, se mueva esa misma cantidad en la dirección Y, y si es mayor se mueva esa cantidad en dirección -Y, no funciona. No hace nada, y hasta que no toco yo el motor de direccion no funciona el motor, y ademas lo hace como resistiéndose al movimiento que yo hago, entendiendo que siempre lee al encenderse, la posición inicial como CERO.
Realmente la "chica" creo que esta tanto en la forma de funcionar del lenguaje este de lego como en como funciona el reseteo y lectura inicial de los grados del motor.
Sino, no se me ocurre otra forma que almacenar en un fichero al finalizar el programa cual ha sido la posicion de parada, para al arrancarlo, leer ese fichero y colocarlo...
(esto se me ha ocurrido ahora mismo sobre la marcha xDD)
Lo más sencillo es hacer una rutina que tome medidas (posición inicial y final de la dirección) y ejecutarla nada mas arrancar la maquina. Simple y directo. ;D
*Rutina: https://es.wikipedia.org/wiki/Rutina
Si es que estos juguetes son más indomables por lo que veo desde mi ignorancia.
Al contrario, son mucho más dóciles... sólo hay que "saber decirles" lo que deben hacer :guino:
Cita de: Jafram en 05 de Marzo de 2007, 23:06:57 PM
Lo más sencillo es hacer una rutina que tome medidas (posición inicial y final de la dirección) y ejecutarla nada mas arrancar la maquina. Simple y directo. ;D
*Rutina: https://es.wikipedia.org/wiki/Rutina
tomar medidas.. vale.. ¬¬ pero cual es esa posicion inicial y posicion final?
las direcciones tiene un tope impuesto fisicamente..
PD: lo de rutina me ha resultado gracioso.. dudo que alguien que use NXT no sepa lo que es una rutina xDDDD
salu2 hijos del lego
Cita de: Wendigo en 06 de Marzo de 2007, 16:53:55 PM
tomar medidas.. vale.. ¬¬ pero cual es esa posicion inicial y posicion final?
las direcciones tiene un tope impuesto fisicamente..
PD: lo de rutina me ha resultado gracioso.. dudo que alguien que use NXT no sepa lo que es una rutina xDDDD
salu2 hijos del lego
Los mensajes que escriba en este foro van en principio dirigidos a todo el foro, con lo cual intentare dar todas las referencias que pueda (aunque parezca gracioso). ::)
En cuanto a tomar medidas, te dejo pensándolo un poco mas, ;D (Para que se debata un poquito) intenta pensar en la solución y cuéntanos. Si veo que no llegas a buen puerto, te dejo un par de soluciónes, pero me gustaría ver a donde llegamos antes ;D (Me podría interesar) :-\
eso, eso, si lo consigues nos lo dices que yo no tengo ni idea de programar ;D
si sigues pensando...
no tengo un NXT, pero por lo que he leído los motores tienen un encoder, es decir deberían saber que están moviendose o no moviendose porque un obstáculo se lo impide. Hace algún tiempo escribí un programa muy sencillo en NQC para el Cybermaster con la misma idea: si las ruedas no giran a la velocidad esperada es que has topado con algo. De ese modo el encoder hacía las veces de un sensor de contacto (tipo parachoques). Si tienes curiosidad puedes encontrar el programa aqui: https://www.brickshelf.com/cgi-bin/gallery.cgi?f=234170 (https://www.brickshelf.com/cgi-bin/gallery.cgi?f=234170)
De la misma manera deberías poder escribir una rutina para calibrar la dirección. Haz girar la dirección hacía la derecha hasta encontrar el tope y pon en cero el encoder (o, si no se puede apunta el valor en una variable) Después gira a tope hacia la izquierda y apunta también ese dato. Ahora resta el primer dato del segundo (caso de no haberlo puesto en cero entonces) y divide entre dos. Ya tienes la posición central.
he tenido un poco apartado el tema porque he estado de obras en casa, he cambiado de curro y bueno.. ahora mismo la "columna de dirección" la he puesto para moverla facilmente manualmente. Lo que me interesa es lo que me has comentado de una rutina para saber en que momento se hace tope y no puede girar más, pues me sería muy muy util tanto para el calibrado como para simular un sensor de toque (aunque este sistema no funciona en mi suelo de parquet porque patina al llegar a una pared).
(un poco offtopic)
también me he encontrado con algo que será absurdo para vosotros que controláis mas, pero no conseguí hacer ejecutar en paralelo el sensor de distancia con los motores.. me explico.
1. compruebo distancia.
2. me muevo X segundos.
3. compruebo distancia.
4. me muevo X segundos.
....
esto se refleja con parones de 1 segundo cuando comprueba la distancia y golpeándose cuando antes de comprobar la distancia de nuevo se mueve X segundos, estando el obstáculo a X-Y segundos para X>Y. Debe ser una chorrada, que no termino de ver en el entorno pero no lo consigo.
a ver si ahora que curro mucho más cerca tengo más tiempo para pasarme y seguir dándole caña.
Por desgracia no conozco el entorno de programación del NXT, pero la solución generica sería usar un 'loop' con 'while' (piensa en una rutina que se repite hasta que se cumple la condición puesta). Hay alguien allí que pueda precisar más?
actualmente uso un bucle, un while, repeat, o loop o como se llame. el tipico
while distancia >10 do
{
mover 10
}
pero hace parones..
¿Que lenguaje de programación usas?
Quieres poner el programa en un mensaje?
uso el de lego, el de los bloques.
realmente mi programa hace esto, lo del NQC que me pasaste pero comprobando la distancia.
while (true)
{
OnFwd (OUT_L+OUT_R);
Wait (20);
if (TachoSpeed(OUT_R) < threshold) //default behaviour
hace como pausas cuando comprueba la distancia..
con el código este que me dijiste no se te paraba cuando comprobaba la distancia?
es que entiendo que durante 20ms se mueven los dos motores hacia adelante, comprueba la si alguna de las dos ruedas no se está moviendo como se espera y así sucesivamente..
corrígeme si me equivoco.
Siguiendo con lo del autocentrado: El problema es que creo que no combino bien el sensor de rotación con el uso del motor. Para practicar con el sensor de rotación hice que me mostrase por pantalla los grados a los que estaba moviendo la dirección yo, partiendo de que 0 fuese la posición de ruedas rectas. Luego le metí que cuando fuese distinto de 0 grados, hiciese un movimiento contrario al que se hacía, el resultado era que no podia mover, porque rapidamente el motor la corregía, pero curiosamente, sólo para un lado... O_o.
La idea puede estar en almacenar en un fichero la última posición en la que estaba el motor, y al encenderlo girar esos grados pero en negativo. El problema es que si se ha movido con el programa apagado ya no lo reconocería.
Tendré que probar a cuando se arranca que gire a tope hacia un lado hasta que no pueda y luego sabiendo que el tope está en 45 grados, pues girarlos en negativo.
En NQC debería ser algo como
While (TachoSpeed (OUT_R) < threshold)
{
OnFwd (OUT_L+OUT_R);
}
muchas gracias, mirare a ver si lo hago en el lenguaje de lego, y sino me pasare al NQC ya de una vez.
el threshold deberia ser la velocidad a la que he puesto el motor, verdad?
ehm... threshold debería ser la velocidad del tacometro.
Cita de: Jetro en 29 de Mayo de 2007, 23:01:15 PM
ehm... threshold debería ser la velocidad del tacometro.
y esto tiene tacómetro? :confundido:
¿usas nxt, no?
Los motores llevan un 'encoder' que lleva la cuenta de cuanto ha girado. En el Cybermaster a ese mismo sistema se accede con TachoSpeed bajo NQC.
sí, NXT. Lo que estoy viendo es que todo lo que he encontrado de NQC en internet es referente a RCX, no a NXT.
Para NXT existe NXC que es muy similar a NQC
por si a alguien que esté empezando le sirve de ayuda, con esto (está sin probar todavía) se controlaría el tema de la distancia para que no se choque con nada por la parte frontal.
task comprobar_sensor_distancia()
{
SetSensorLowspeed(IN_4);
while (true)
{
distancia_actual=SensorUS(IN_4);
if (distancia_actual < DISTANCIA_MINIMA){
//decidir que dirección tomar
//poner semáforo
OnRev(OUT_AC, 75);
}
}
lo ideal para "decidir la dirección a tomar", sería tener dos ultrasónicos frontales y así poder decir que tiene que girar al lado contrario al del ultrasónico que tiene el objeto más próximo.
que haceis vosotros ver que direccion tomar cuando un obstáculo? aleatoria, siempre a la misma?
No tengo la 'fortuna' de tener un nxt, pero el problema se me antoja similar al de buscar la zona de mas luz con el sensor de luz y el rcx.
Con un poco de ayudo escribí el siguiente código NQC, aunque en este caso la tarea era encontrar la zona con mas luz en vez de evitarla. (como el foro no accepta ficheros con extensión nqc tendras que cambiarlo tu mismo)
Existen en el NXC unas sentencias "avanzadas" para los motores, básicamente son 3, la del funcionamiento normal, otra en la que si un motor pierde velocidad el motor empuja más para compensar (todo lo contrario al control de traccion de un coche jeje) y la última es que si coges una rueda/motor y la sujetas se ralentiza la otra con la que esté asociada.
OnFwdReg(OUT_AC,50,OUT_REGMODE_IDLE); //normal
OnFwdReg(OUT_AC,50,OUT_REGMODE_SPEED); //mas potencia para mantener velocidad
OnFwdReg(OUT_AC,50,OUT_REGMODE_SYNC); //si se ralentiza una se ralentiza otra
Yo creo que ninguna de las tres opciones vale para el autocentrado y para evitar el deslizamiento en caso de chocar con algo que no haya visto por delante ni sentido por detrás.
He puesto avanzadas antes entre comillas porque luego hay otra opción, PID Control, que parece muy interesante pero hay mucho que investigar.
Tengo que ver si no hay ningún problema en cambiar un puerto de sensor de rotación a motor, y empezar a investigar también por ese lado lo del sensor de rotación.
PD: me enrollo más que las persianas ¬¬
Creo que lo que necesitas es MotorTachoCount o similar
Cita de: Jetro en 07 de Junio de 2007, 13:38:23 PM
Creo que lo que necesitas es MotorTachoCount o similar
Probé el TachoSpeed ese que me pusiste en un enlace pero no lo reconoce el NXC, el MotorTachoCount parece que si que lo pilla :D muchas gracias,
Leete esto: https://bricxcc.sourceforge.net/nbc/nxcdoc/NXC_Guide.pdf (https://bricxcc.sourceforge.net/nbc/nxcdoc/NXC_Guide.pdf)
Cita de: Jetro en 07 de Junio de 2007, 19:58:09 PM
Leete esto: https://bricxcc.sourceforge.net/nbc/nxcdoc/NXC_Guide.pdf (https://bricxcc.sourceforge.net/nbc/nxcdoc/NXC_Guide.pdf)
ahi encontre luego el que me dijiste.. es una animalada, entre el tutorial y la guia, 100 paginas de NXC... en el metro me voy a entretener mucho jeje.
Como yo con la versión para RCX (NXC). Creo que lo he leído 3 veces y aún así no entiendo la mitad.
Cita de: Jetro en 08 de Junio de 2007, 09:29:38 AM
Como yo con la versión para RCX (NXC). Creo que lo he leído 3 veces y aún así no entiendo la mitad.
es que la guía es en plan API a piñon, "funcion(parametros)" así 50 y pico paginas... pero bueno, me gusta muchísimo más que los dichosos bloques. Además se hace más rápido.