Controlar servos para desvios con pulsador y Arduino

haute escribió:

Pero lo del soporte y la leva para accionar el microswitch es una pasada, esto es otro nivel. Aqui lanzo una pregunta, es realmente necesario poner un switch en cada servo?, he visto incluso hasta 2 en algunos montajes. Dentro de mi desconocimiento, para que vale? para indicar al software que realmente se ha cambiado el cruce?, es indispensable? o se le puede dar un tiempo al software para que simule como si ha pulsado un switch?

El primer soporte fue con angulo de aluminio, swichpilotservo + swichpilot extension, pero lo vendi todo para pasar a arduino y mis soportes. Ahora incluso otros compañeros de modulos estan montando estos soportes en 3D en sus modulos en construccion.

Sobre el micro, en mi caso lo utilizo para cambiar la polaridad del corazon del desvio. Si la polaridad se cambia mecanicamente, ahorras reles y programacion, por que si o si (excepto si falla el micro), la polaridad siempre sera la correcta. De la otra manera, tienes que programar el servo, que se espere un poco para cambiar el rele en el momento que ninguna aguja toque los railes, etc.

Saber si un desvio esta recto o desviado, para esto esta el soft y en el confio. Yo tengo montados dos leds bicolores por aguja, y cuando pulso, los dos destinos se ponen en rojo, el servo hace su funcion y 4 segundos despues pongo en verde el recorrido correcto. Ademas voy a conectar todas los "semaforos" (señales) para que se enciendan en funcion del recorrido disponible. Le he dicho que haga esto y debe hacerlo, y si no lo hace es que hay una averia y debera ser reparada. No considero necesario poner un micro mas para confirmar ese movimiento. Y esto es un gustazo cuando vas a un encuentro y tienes el modulo conectado 10 horas seguidas sin que de ningun fallo.

El Matao escribió:

Pero no encuentro documentación de la función ISR (o lo que sea, pues le falta el void delante) ni relación con las ¿variables? TIMER1_OVF_vect y TIMER1_COMPA_vect

Esto forma parte de las características del microprocesador AVR 328 que llevan los Arduinos. Está en su manual.

El Matao escribió:

Que conste que no dudo del código, además, sería (espero que será ) muy fácil con la función dcc_int hacer un monitor dcc básico del tipo..

En principio sí pero con una salvedad. Los paquetes DCC entran muy rápido al micro. Si el sacarlos por pantalla llevase más tiempo entonces sacarías un resultado poco coherente. Asegúrate de que la comunicación entre el Arduino y el ordenador que te muestre los paquetes sea lo más rápida posible (115200 baudios mejor que solo 9600 baudios y así).

Gracias Norber, lo miraré con calma.

Lo de la velocidad al ser por USB emulando un puerto serie no pensaba que fuese tan importante, pero también lo tendré en cuenta.

Un saludo.

haute escribió:

Respecto al sketch de Norber, lo he intentado, pero no acierto a hacerlo funcionar por un tema de la asignación de la address

Tal como está controlas el servo conectado al pin8 con la dirección 0005 del Multimaus, el servo del pin9 con la dirección 0006 del Multimaus y así hasta el pin13, que si te fijas está configurado como esServo = false y por eso en la 0010 Multimaus se controla la lucecita de los Arduinos como un accesorio sí/no.

Es que he puesto la versión 'pequeña', que no lleva una forma más elaborada de trabajar con direcciones. Si te fijas, está explicado al principio del código: DIREC1 129 significa controlar los servos con 0005 a 0008 del Multimaus; después DIREC2 130 son el 0009 y el 0010. Es decir: puedes cambiar DIREC1 o DIREC2 y alteras las direcciones Multimaus en consecuencia.

haute escribió:

estoy deseando también probar tu sketch, pero me gustaría que fuera de 10 o mas servos.

Prueba primero con 6, como está. Si te gusta, lo subimos a 10 servos. Hay un límite teórico en eso: se supone que hay que mandar a los servos un pulso de control cada 20 ms, y se supone también que si el pulso dura 2 ms entonces el servo se va al final de su carrera. Haciendo cuentas para el caso más desfavorable, es decir, el caso en que todos los servos se tuvieran que ir al final de sus respectivas carreras, se requerirían pulsos de 2 ms en cada uno, con lo que si pones 11 servos harían falta 2 x 11 = 22 ms, que son más que 20 ms y violaríamos la regla de un pulso cada 20 ms (estaríamos dando un pulso cada 22 ms). Esto creo que está detrás del problema de otros códigos DCC+servo que venimos comentando, pero que el nuestro respeta a rajatabla.

Todo esto hablando de mover hasta 10 servos a la vez. Si fuera necesario mover hasta 19 servos, entonces la solución vendría de renunciar a mover tantos a la vez. Bunza mueve 17 a la vez, luego me parece que debe violar la regla de los 20 ms. ¿No es una regla rigurosa? No lo sé. La información que tengo dice que sí.

Norber, me es imposible hacerlo funcionar, estoy usando un arduino pro mini, he probado incluso con el rocrail poniendo dir 3 port 1 que corresponde a la direccion 9 de roco. En el jmri he probado 129, 130, 5 , 9 1 etc.. y nada.

Hola Haute. Te conteste en el foro de Mr Bunza
El ejemplo AccessoryDecoder_15ServosReleased_2LED_4Function.ino. del Sr. Bunza implementa el detach del que hablais.
Pruebala para ver si va mejor.

Un saludo

haute escribió:

Norber, me es imposible hacerlo funcionar

Conecta un servo así:
- cable naranja del servo al pin8 de Arduino
- cable rojo del servo a +5 V cc de una fuente solvente
- cable marrón del servo a GND común del Arduino y la fuente anterior
Vuelca el programa tal cual y prueba el accesorio 0005 en Multimaus. Es el servo
Prueba el accesorio 0010 en Multimaus. Es la luz asociada al pin13 de todos los Arduinos.
Así debería funcionar si estás leyendo bien la señal de la vía a través del pin2 (optoacoplador 6N137 etc)
Verifica malas conexiones, falsos contactos, etc.

segovia escribió:

Hola Haute. Te conteste en el foro de Mr Bunza
El ejemplo AccessoryDecoder_15ServosReleased_2LED_4Function.ino. del Sr. Bunza implementa el detach del que hablais.
Pruebala para ver si va mejor.

Un saludo

Hola segovia, juer, lo he tenido delante las narices y no me he dado cuenta, no entiendo porque no lo ha aplicado a todos los sketch si va mejor. Usaré este sketch mejor como patrón. Gracias, ahora toca implementar el codigo para hacerlo mas lento y los botones por los puertos A6 y A7, no creo tarde muho. Así ya serán los 16 o 17 servos.

Norber: El problema es que no tengo el multimouse aquí, que lo tiene mi Padre en su casa, yo puedo usar el Sprog3 y es lo que estoy haciendo y probando todos los sketch con Rocrail y JMRI y todos funcionan menos el tuyo, que supongo sera por un problema de no dar con la address adecuada supongo.
Por poner un ejemplo en el código de Bunza pongo en el JMRI address 40 y mueve el primer servo en el pin 3. En Rocrail tengo que poner dir 0 y puerto 40 y funciona. Pero tu sketch no hay manera.

haute escribió:

El problema es que no tengo el multimouse aquí,

La peculiaridad del sistema de numeración de accesorios del Multimause es que los considera desplazados 4 lugares, nunca recuerdo si más arriba o más abajo. Luego el accesorio Multimaus 0005 se puede mover como si fuera el accesorio nº1 ó nº9 (no recuerdo) de otro sistema que no los desplace 4 lugares.

Buenas a todos!!! esta el tema calentito si jejejeje, Bueno gracias a los que habéis probado mi código, pelin chapucero, pero bueno es con lo que empece y lo tenia en el tintero por que como dice haute, el servo si le das al 1 vuelve a su posición y vuelve a cambiar cuando si ya esta en el 1 no tendría que hacerlo. Así que este Lunes me puse manos a la obra y empece a meterle mano al código, creo que ya tenia la peor parte que era lo del DCC así que tenia que pulir lo del tema de los servos. Pues bien eso ya esta arreglado, ya si le das al On y esta en esa posición, el servo no se moverá. Al añadirle un bit de estado también he podido configurar para que se le pueda indicar al programar si queremos que este abierto o cerrado por defecto (1/0). Y también algunas salidas para poder ver lo que se recibe mediante el Monitor Serial del IDE de Arduino.

Pues para el tema de accesorios si que me gusta más la de DCC que la de NmraDCC, pero también hice mis pruebas para decodificadores de funciones con estos últimos y me pareció que era más fácil con la de NmraDCC.

Haute una de tus dudas me parece que es con las direcciones, en la mi sketch empieza por la 1 ( "case 1; ") pero la puedes cambiar, si quitas el 1 y pones la 22 ese servo o función pasa a ser la 22 y en el de Bunza pasa lo mismo si cambias el 40 y pones el 10 empezara por ahí.
en mi caso para este módulo (por el momento) solo hay tres desvíos y la puerta de la cochera + las luces de la cochera 5 funciones en total y a cada servo esta asociado un pin para poder poner un semáforo o un rele para el corazón polarizado, o ambos a la vez. que es casi lo mismo que hacerlo por microswitch.
¿JMRI lo usas desde Windows o desde Linux? por que en Linux me vuelvo loco, le he intentado echar alguna tarde, pero nada. ¿se puede conectar al PC con Arduino?


Una cosa que no tengo clara es el tema de programar las Cvs pero seria muy interesante echarle un ojo, tiene pinta de ser muyyy cómodo jajajajaja.

Por cierto ERG una pasada esos soportes para servos ¿son para servos de 9g? Estuve mirando en thingiverse pero no encontré nada que fuera muy de mi agrado, así que recurrí a la silicona térmica.

Bueno este es el código después de un repasito:

Código: Seleccionar todo

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Arduino Servo DCC y Decoder de funciones
// Version: 1.4 - 2015-04-23
// Author: Ruud Boer | Traduccion Carlos Muñoz
// Este sketch Comvierte un Arduino en un decoder DCC con salida para 12 servo motores combinadas con salidas de funciones
// como por ejemplo semaforos
// La señal DCC es separada optimcamente y alimenta el pin2 (=Interrupt 0). Esquema: www.mynabay.com
// Muchas gracias a www.mynabay.com por publicar su DCC monitor y -decoder code que se utiliza en este sketch.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// IMPORTANT: Mira las lineas 27 y 28 para configurar algunos datos!
// IMPORTANT: Para evitar el movimiento del servo y el posible alto consumo de corriente en el arranque:
// - En el primer inicio deArduino, el servo se iniciara en en el angulo dado en 'offangle'.
// - Después de unos segundos, cambie el servo a encendido ... posiblemente mostrarán sólo una minima fluctuación menor.
// - Esto solo funciona si se establecen todos los servos a 'offangle antes de apagar!
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <DCC_Decoder.h>
#include <Servo.h>
#define kDCC_INTERRUPT 0

Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
const byte maxservos = 4; //Numero de servos que hay conectados a este Arduino.
const byte servoTimer = 30; //Tiempo de cambio de angulo del servo. A menor valor -> mayor velocidad.
const byte servoDoor = 50;
//Servo1******
int sMin1=50;  //Valor minimo del servo2
int sMax1=85;  //Valor maxi del servo2
int sVar1;
//Servo2******
int sMin2=80;  //Valor minimo del servo2
int sMax2=120;  //Valor maximo del servo2
int sVar2;
//Servo3******
int sMin3=65;  //Valor minimo del servo2
int sMax3=100;  //Valor maximo del servo2
int sVar3;
//Servo4******
int sMin4=0;  //Valor minimo del servo2
int sMax4=100;  //Valor maximo del servo2
int sVar4;
//****Estado inicial de las funciones
int sState1=0;    //Cambiando este valor 0/1
int sState2=0;    //el desvio empezara abierto o cerrado
int sState3=0;
int sState4=0;
int lInState=0;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Gestion de paquetes DCC
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
{

  // comvierte los paquetes de direcciones NMRA a un formato humano de direccion
  address -= 1;
  address *= 4;
  address += 1;
  address += (data & 0x06) >> 1;
  boolean enable = (data & 0x01) ? 1 : 0;

  Serial.print("Direccion de accesorio: ");
  Serial.print(address);
  Serial.print(" Estado del accesorio: ");
  Serial.print(enable);
 
  switch (address){

  case 1:  //****Direccion de accesorio 1, pon la que quieras dentro del rango de 0 a 255.
    servo1.attach(4);                  //Esta direccion es UNICA. Aunque se pueden la misma direccion
    if ((enable==0) && (sState1==0)){  //en varios decos para enceder, por ejemplo, las luces de toda la maqueta
      for(sVar1 = sMin1; sVar1 <= sMax1; sVar1 += 1){                                 
        servo1.write(sVar1);   
        delay(servoTimer);
      }
      digitalWrite (8, HIGH);
      sState1 = 1;
    }   
    if ((enable==1) && (sState1==1)){
      for(sVar1 = sMax1; sVar1 >= sMin1; sVar1 -= 1){                                   
        servo1.write(sVar1);             
        delay(servoTimer); 
      }
      digitalWrite(8,LOW);
      sState1 = 0;
    }
    servo1.detach();
    break;


  case 2:    //****Direccion de accesorio 2, pon la que quieras dentro del rango de 0 a 255.
    servo2.attach(5);
    if ((enable==1) && (sState2==1)){
      for(sVar2 = sMin2; sVar2 <= sMax2; sVar2 += 1){                                 
        servo2.write(sVar2);   
        delay(servoTimer);       
      }
      digitalWrite (9, HIGH);
      sState2= 0; 
    }   
    if ((enable==0) && (sState2==0)){
      for(sVar2 = sMax2; sVar2 >= sMin2; sVar2 -= 1){                                   
        servo2.write(sVar2);             
        delay(servoTimer); 
      }
      digitalWrite(9,LOW);
      sState2 = 1;
    }
    servo2.detach();
    break;
  case 3:    //****Direccion de accesorio 3, pon la que quieras dentro del rango de 0 a 255. 
    servo3.attach(6);
    if ((enable==0) && (sState3==0)){
      for(sVar3 = sMin3; sVar3 <= sMax3; sVar3 += 1){                                 
        servo3.write(sVar3);   
        delay(servoTimer);       
      }
      digitalWrite (10, HIGH);
      sState3 = 1; 
    }   
    if ((enable==1) && (sState3==1)){
      for(sVar3 = sMax3; sVar3 >= sMin3; sVar3 -= 1){                                   
        servo3.write(sVar3);             
        delay(servoTimer); 
      }
      digitalWrite(10,LOW);
      sState3=0;
    }
    servo3.detach();
    break;
  case 4:    //****Direccion de accesorio 4, Puerta de cochera.
    servo4.attach(7);
    if ((enable==1) && (sState4==0)){
      for(sVar4 = sMin4; sVar4 <= sMax4; sVar4 += 1){                                 
        servo4.write(sVar4);   
        delay(servoDoor);       
      }
      sState4=1;
    }   
    if ((enable==0) && (sState4==1)){
      for(sVar4 = sMax4; sVar4 >= sMin4; sVar4 -= 1){                                   
        servo4.write(sVar4);             
        delay(servoDoor); 
      }
      sState4=0;
    }
    servo4.detach();
    break; 
  case 5:  //****Direccion de accesorio 5. Luces farolas
    if ((enable==1) && (lInState==0)){
      analogWrite (11, 127);
      delay(10);
      digitalWrite (11,LOW);
      delay(100);
      analogWrite(11,127);
      delay(100);
      digitalWrite(11,LOW);
      for (int encendido = 100;encendido <=255;encendido++){
        analogWrite (11, encendido);
        delay(25);
      }
      lInState=1;
    }
    if ((enable==0) && (lInState==1)){
      digitalWrite (11, LOW);lInState=0;
    }
  }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// configuracion (se ejecuta una vez)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
  Serial.begin(9600);
  DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
  servo1.attach(4);    //Adjuntamos el pin 4 a servo1
  if (sState1==0){
    sVar1 = sMin1;
    servo1.write(sVar1);
    Serial.println("desvio 1 recto ");
  }
  if (sState1==1){
    sVar1 = sMax1;
    servo1.write(sVar1);
    Serial.println("desvio 1 abierto ");
  }
  servo2.attach(5);    //Adjuntamos el pin 5 a servo2
  if (sState2==1){
    sVar2 = sMin2;
    servo2.write(sVar2);
    Serial.println("desvio 2 abierto ");
  }
  if (sState2==0){
    sVar2 = sMax2;
    servo2.write(sVar2);
    Serial.println("desvio 2 recto ");
  }
   servo3.attach(6);    //Adjuntamos el pin 6 a servo3
  if (sState3==0){
    sVar3 = sMin3;
    servo3.write(sVar3);
    Serial.println("desvio 3 recto ");
  }
  if (sState3==1){
    sVar3 = sMax3;
    servo3.write(sVar3);
    Serial.println("desvio 3 abierto ");
  }
    servo4.attach(7);    //Adjuntamos el pin 7 a servo4
  if (sState4==0){
    sVar4 = sMin4;
    servo4.write(sVar4);
    Serial.println("Puerta cochera cerrada ");
  }
  if (sState4==1){
    sVar4 = sMax4;
    servo4.write(sVar4);
    Serial.println("Puerta cochera abierta ");
  }
  delay(300);
  servo1.detach();  //Para el servo1
  servo2.detach();  //Para el servo2
  servo3.detach();  //Para el servo3
  servo4.detach();  //Para el servo4
  DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
  pinMode(2,INPUT_PULLUP); //Interrupcion 0 con resistencia interna pull up (can get rid of external 10k)

  pinMode(8,OUTPUT);    //salida semaforos servo1
  pinMode(9,OUTPUT);    //salida semaforos servo2
  pinMode(10,OUTPUT);    //salida semaforos servo3
  pinMode(11,OUTPUT);    //salida Luces Faroras
  digitalWrite(8,LOW);    //Salida apagada al empezar
  digitalWrite(9,LOW);    //Salida apagada al empezar
  digitalWrite(10,LOW);   //Salida apagada al empezar
  digitalWrite(11,LOW);   //Salida apagada al empezar
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// loop principal (se ejecuta continuamente)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void loop()
{

  DCC.loop(); // Libreria DCC
}


Sañudos!!!

Peyu escribió:

Por cierto ERG una pasada esos soportes para servos ¿son para servos de 9g? Estuve mirando en thingiverse pero no encontré nada que fuera muy de mi agrado, así que recurrí a la silicona térmica

Son para servos standard. Tengo mania a los servos mas pequeños (todos tenemos manias, y esta es una de las mias, tengo mas) por que los considero mas ruidosos, menos suaves en sus movimientos, etc. Y habiendo espacio y por pocos centimos mas, standard si o si.

Peyu: El JMRI lo uso en windows, de linux tengo mas bien poca idea. Y lo uso con un pequeño aparatejo que lo compre con idea de programar los decoders de las maquinas, pero que vale también como command station, y da hasta 2,5A, lo cual no está nada mal. http://www.sprog-dcc.co.uk/.
Gracias Peyu por el update, lo guardo y lo miro.
Ya parece que solucionaste el tema de la posición si das al mismo lado, pero he visto una cosa que no me convence. Solo se puede mover 1 solo servo al mismo time. No se que pasaría si tenemos un cruce de dos vías en cruz y hay que cambiar los cruces una detrás de otro. Creo que es algo importante que deberías de mirar, aunque quizás requiera mucho cambio en el sketch.

La librería NMRA_dcc permite lo de programar CV, resetear el decoder, cambiar la CV de cada servo etc.... No lo he estudiado mucho, pero no parece muy complicado.

Norber: Voy a probar eso que me comentas lo del desplazamiento de las direcciones a ver si lo consigo hacer funcionar.
Bueno al fin ya funciona, pero es algo curioso, funcionan los pines de salida del 9 al 13 con las addres del 2 al 6, pero la salida pin 8 no funciona con el address 1 y no lo puedo hacer funcionar. es algo extraño.
Otra cosa que habría que modificar seria poder poner los limites individuales a cada servo. La velocidad como es para desvíos, sera siempre la misma.
Otra cosa que he notado es que después de un reset del arduino, si le doy a mover el servo, pego un estrincon fuerte y justo después empieza a mover

A todos: que material usais para conectar el servo al cruce?, que no sea difícil de conseguir.

Haute yo implemente tu codigo para hacer mas lento el movimiento en ese skecth y funcionaba bien.
Mr Bunza, en unos comentarios dice que pensaba aplicar la mejora del detach en sus ejemplos poco a poco por falta de tiempo.
Estoy muy interesado en esa funcionalidad que vas a implementar para ajustar el principio y el fin del movimiento del servo. Cuando lo tengas hazmelo saber. Gracias.
Por cierto,por curiosidad ,como vas a seleccionar el servo al que se le van a aplicar dichos limites?
Un saludo

segovia escribió:

Haute yo implemente tu codigo para hacer mas lento el movimiento en ese skecth y funcionaba bien.
Mr Bunza, en unos comentarios dice que pensaba aplicar la mejora del detach en sus ejemplos poco a poco por falta de tiempo.
Estoy muy interesado en esa funcionalidad que vas a implementar para ajustar el principio y el fin del movimiento del servo. Cuando lo tengas hazmelo saber. Gracias.
Por cierto,por curiosidad ,como vas a seleccionar el servo al que se le van a aplicar dichos limites?
Un saludo

Hola, varios temas:
En principio la modificación que hice para hacerlo mas lento, no se si funciona al 100% en 17 servos. Si puedes pruebalo con cada una de las 16 salidas y si puedes mejor coloca 16 servos, yo es que de momento solo tengo 2.
Si te fijas en el nuevo código que implanté creo que puse un 8 para slow, podrías poner creo que 15 o 16 para superslow creo que podría funcionar. Este numero es muy critico, no se puede poner cualquier numero, en teoría tiene que ser o el mismo numero que el numero de servos menos 1, o la mitad menos 1.
Lo que hace el código exactamente es ignorar un numero de veces que se mueva cualquier servo, pero esto tiene que ir en sincronia con las veces que le llega la orden a cada servo, por eso solo puede ser o el mismo numero o la mitad creo. Si se rompe esta regla algunos de los servos no actuaran, por eso te digo si puedes hacer la prueba con los 17.

Por otro lado, ya tengo el código con detach para 12 servos, funcionando los 12, en este caso el numero mágico pasa a ser 5 para slow y 11 para super slow. Después las velocidades de cada servo se configuran en cada CV de cada servo.
Con el resto de pines de sobra, que son 5, Uno que es el pin 13 (led en placa) lo uso para verificar la memorización de las posiciones en las CV. Luego 4 pulsadores, El pin 16 pos. start, pin 17 pos. stop, pin 18 next servo y pin 19 grabar las pos. en cv.
Después por el pin de solo entrada A6 uso un interruptor para conmutar a modo programación.
En modo programación, el primer servo se posiciona en 90º, y entonces ajustas con los botones(start y stop), un lado y lo memorizas, ajustas el otro lado y lo memorizas. Si pulsas next, el segundo servo se posiciona en 90º y si quieres lo ajustas o sino no, y pasas al siguiente, así hasta los 12, después pasa al 1 servo. En modo programación, ves por el puerto serie todos los números, cuando programas, en que servo estas, etc...
Una vez que sales del modo programación cada servo vuelve a suposición de origen o la nueva que hayas programado, esta programación se graba en sus CV de cada servo.
Cuando lo tenga lo pongo.

haute escribió:

[Norber:...al fin ya funciona, pero es algo curioso, funcionan los pines de salida del 9 al 13 con las addres del 2 al 6, pero la salida pin 8 no funciona con el address 1 y no lo puedo hacer funcionar. es algo extraño.

Ja, ja, ja. Debe haber algún error en el código porque a mi me pasaba exactamente lo mismo la otra noche. Pero como usaba un micro 'tocado' tras un cortocircuito (con humo y todo!) creí que era porque el pin8 se me había quemado. Ahora veo que no, ja, ja, ja. Debe ser fallo de software. El primero que lo encuentre se gana una cerveza! .

haute escribió:

Otra cosa que habría que modificar seria poder poner los limites individuales a cada servo. La velocidad como es para desvíos, sera siempre la misma.

Eso es fácil.

haute escribió:

Otra cosa que he notado es que después de un reset del arduino, si le doy a mover el servo, pego un estrincon fuerte y justo después empieza a mover.

Eso llevará algo más de tiempo probablemente.

Ten en cuenta que puse un código apañado y probado rápidamente, y agradezco todas estas observaciones, y más que saldrían seguramente con más pruebas tuyas o de más gente. De hecho esta es una de las pocas veces en las que he podido obtener una colaboración así en este foro (y otros), algo que me gusta y que he visto en páginas extranjeras, con cierta envidia. ¿Somos demasiado tímidos para atrevernos a cosas nuevas? ¿O demasiado educados para molestar probando? Si lo que faltan son conocimientos, en internet hay miles de sitios donde ya se explican las cosas básicas poco a poco. Así hemos empezado los demás.
Gracias.

Os leo, sabiendo lo que queréis hacer, pero sin entender nada del lenguaje, dado vuesto nivel. Sé lo que es arduino, y que tiene una librería específica de servos. Y lo que es el mutimaus y cómo se utiliza y programa. Por ello quisiera preguntaros lo siguiente. ¿Es posible dado vuestro nivel que os atreviérais a poner un tutorial? cuando veáis luz para ello, u ¿os meto en un follón?.

Me refiero a..... un ejemplo para x servos:

Conectar cada servo así:
- cable cable naranja del servo a los pines de Arduino, 1,2,3,4,.. por orden, y sin utilizar por ejemplo el pin...
- cada cable rojo del servo a +5 V cc de una fuente externa
- cable marrón del servo a GND común del Arduino y la fuente anterior

Utilizar la librería de arduino de servos, (sustituir.......por..., o cambiar.....lo que sea)....

En fín, no pretendo un curso, ni aprovecharme de algo que veo que os lo currais, pero bien currado. Ni volveros locos con preguntas de todos. Sino a que podamos realizar un montaje estándar de servos con el Multimaus. Gracias y perdonad por el rollo. Adolfo

Rokiski si lo que no se es como no terminamos chalaos aquí cada uno con un sketch diferente jajjajajaj aunque bueno así luego hay más de donde elegir. Pero si no estaría mal un paso a paso.

haute te refieres hacer rutas (es que lo he descubierto hoy bajándome el manual del Prodigy Express con los cruces y cuidado aquí que lo mismo estoy cometiendo sacrilegio.... ¿no conectas los dos servos al mismo canal? yo al menos lo tengo así:



Así solo me ocupa un pin los dos, pero supongo que los entendidos sabrán si esto es así o hay que poner los dos separados, Pero vamos poniéndolo así y con un mínimo ajuste a mi me funciona perfectamente.

Lo de programarlo mediante CV,s pues tiene pinta de ser muy cómodo sobre todo si tienes muchos desvíos, pero es que también creo que es una cosa que una vez ajustado no lo vuelves a tocar... pero molar mola. También es que mi maqueta es "pequeña" y tiene solo 10 desvíos y no me importa configurarlos a mano.

Lo que si creo que voy a echar de menos es que el micro pueda hacer otras cosas mientras no se le diga lo contrario, por ejemplo hacer blink con leds para poner un paso a nivel.

A ver si me pongo y pruebo los demás sketchs a ver que tal van que siempre voy pegao jajajajjaja
Saludos!!!

Peyu: Desde mi desconocimiento de los software Rocrail o JMRI, creo que se tendría que configurar en el software, lo que no se es como, a ver si los entendidos nos dicen. Sería dar a un desvio en la pantalla del ordenador y que cambiaran los 4 a la vez. Es como lo que has dibujado pero otro cruce en el otro sentido, una X. Se puede tratar como 4 cruces individuales , pero también como un cruce solo, o pasan los trenes en paralelo o cruzados.

Respecto a lo de conectar los dos servos al mismo pin, no se si es buena idea. Si tienen ajustes diferentes ya no se podría por ejemplo.
El tema de tener ajustes independientes en cada servo es fundamental, ya que no siempre vamos a ser perfectos y pondremos el servo siempre en el mismisimo centro, sobre todo si meternos debajo del tablero ya nos cuesta por no tener espacio o vete tu a saber que.
Lo único bueno que tiene esa técnica es que te ahorras pines del arduino, pero estando a menos de 2€ cada arduino pro mini, no se si merece la pena.

En mi maqueta tengo 4 servos conectados a la misma salida, y no da ningun problema.



Y lo del blink para el paso a nivel, si no se utiliza delay en el codigo, no es problema.

haute escribió:

Si te fijas en el nuevo código que implanté creo que puse un 8 para slow, podrías poner creo que 15 o 16 para superslow creo que podría funcionar. Este numero es muy critico, no se puede poner cualquier numero, en teoría tiene que ser o el mismo numero que el numero de servos menos 1, o la mitad menos 1.
Lo que hace el código exactamente es ignorar un numero de veces que se mueva cualquier servo, pero esto tiene que ir en sincronia con las veces que le llega la orden a cada servo, por eso solo puede ser o el mismo numero o la mitad creo. Si se rompe esta regla algunos de los servos no actuaran, por eso te digo si puedes hacer la prueba con los 17.

No acabo de entender esto que dices y me gustaria hacerlo. Entiendo que cuando pones por ejemplo 8 el servo se mueve una vez de cada 8 veces que en teoria se deberia mover, pero porque debe ser el numero de servos -1 o la mitad menos 1?. Podrias extenderte en este punto? Gracias