Índice general Foros Digital, Electricidad e Informática Controlar servos para desvios con pulsador y Arduino

Controlar servos para desvios con pulsador y Arduino

Moderador: 241-2001



Desconectado
Mensajes: 43
Registrado: 11 Feb 2014 09:47
Norber escribió:
El montaje de Geoff Bunza que citas tiene una pequeña pega, y es que está dando señal constantemente a cada servo, de manera que no es raro oír como un pequeño crepitar cada pocos segundos, que se debe a que el software no deja quieto un servo que ya ha llegado a su posición, sino que constantemente lo obliga a ir a ella con poco éxito… El término inglés es jittering. Creo que así los servos envejecerán muy pronto.
.


Pues me has roto todos los esquemas, mañana me llegan los servos a ver como pinta. Hay algún modulo de este estilo (con arduino) que no cometa este error?.
He estado mirando el codigo y creo que se podría arreglar, creo que es en esta zona:
     case 2:
        {
        if (ftn_queue[i].increment > 0) {
          if (ftn_queue[i].current_position > ftn_queue[i].stop_value)
            ftn_queue[i].current_position = ftn_queue[i].stop_value;
        }
        if (ftn_queue[i].increment < 0) {
          if (ftn_queue[i].current_position < ftn_queue[i].start_value)
            ftn_queue[i].current_position = ftn_queue[i].start_value;
        }
        set_servo(i, ftn_queue[i].current_position);


la función "set_servo" (es la que hace mover al servo) siempre se ejecuta , cambie o no la posición. Habría que poner un condicional de que se ejecute si solo cambia la posición supongo.
Te pido tu opinión ya que he empezado hace poco con arduino.


Desconectado
Mensajes: 761
Ubicación: Salamanca
Registrado: 12 Ene 2012 14:44
Prueba primero tal y como viene.
Si lueg oyes el crepitar de los servos, mejora su alimentación (usa una fuente de 5Vcc competente, no los alimentes desde el USB).
Si aún así crepitan, entonces supongo que desactivarlos por software sería suficiente, pero yo no lo hice así, sino que me hice mi propio código y pasé del ofrecido por Bunza. Lo cierto es que creo que intenté arreglar el de él porque el fragmento que has incluido me suena mucho, pero debe ser que desistí y me hice el mío. No sé dónde lo tengo. Quizá debería buscarlo y preparar un montaje curioso...
Saludos

[Multimaus + GenLi-S88 + +z21f. + RocRail (MacOsX)]
H0 Renfe, sin catenaria


Desconectado
Mensajes: 43
Registrado: 11 Feb 2014 09:47
Norber escribió:
Prueba primero tal y como viene.
Si lueg oyes el crepitar de los servos, mejora su alimentación (usa una fuente de 5Vcc competente, no los alimentes desde el USB).
Si aún así crepitan, entonces supongo que desactivarlos por software sería suficiente, pero yo no lo hice así, sino que me hice mi propio código y pasé del ofrecido por Bunza. Lo cierto es que creo que intenté arreglar el de él porque el fragmento que has incluido me suena mucho, pero debe ser que desistí y me hice el mío. No sé dónde lo tengo. Quizá debería buscarlo y preparar un montaje curioso...

Hola, al final me llegaron los servos y al principio uno de ellos hacia mucho ruido (crepitaba) incluso en vacio, seguí haciendo pruebas suponiendo que ese servo estaría defectuoso y el otro no, pero al de un tiempo y tras leer tu mensaje, me ayudo a entender que el problema era de la alimentación, asi que con fuente externa ya van mas finos. Gracias por esos trucos que nos ayudan.

El siguiente paso fue montar el servo y probar diferentes distancias de pivote y diferentes materiales para el vástago que moverá la aguja. Probe con un clip de aluminio estirado (lo de colores) y con hilo de nicrom sacado de un viejo secador de pelo, que es un alambre muy fino y con bastante efecto memoria pero sin oponer mucha resistencia.

Punto de Pivote llamo al pequeño agujero en el alumino por donde pasa el vástago.

Entre las dos opciones creo que la mejor es el hilo de nicrom, al menos con el software de Bunza. Por un lado, podemos conseguir que un vagón sea capaz de mover el cruce en un retorno si el desvío no esta en su posición, para este montaje hace falta que el punto de pivote se separe al menos 4cm de la superficie del desvío. Adjunto foto, que he tenido que poner tuercas y plástico para conseguir esa separación.
Si no necesitamos que los vagones desplacen el desvío, podemos acercar el punto de pivote a ras de la madera, adjunto foto también.
Pero lo que está claro es que con este software, siempre intenta estar en la posición que tiene estipulada, si no llega a ella porque la varilla pone mucha resistencia, se queda el servo crepitando al intentar llegar y no poder. En cambio como el hilo de nicrom ofrece poca resistencia, el servo llega a su posición y no decrepita, algún chasquido aislado pero muy poco.

Intentare ver si modificando el código se puede evitar que el servo siempre intente mantener la posición. Pero no se si podré.
Otra cosa que he notado, es que la velocidad mínima del código de Bunza no es todo lo lenta que desearía. Se configura en una CV, al igual que los límites start y stop del servo.

Si pudieras encontrar ese código que mencionas y compartirlo sería un puntazo, por cierto valdría también para 17 servos con un Arduino min pro, puedes variar la velocidad?.

Las fotos no son muy buenas que no tire flash.

Un saludo.
Imagen Imagen


Desconectado
Mensajes: 761
Ubicación: Salamanca
Registrado: 12 Ene 2012 14:44
haute escribió:
Pero lo que está claro es que con este software, siempre intenta estar en la posición que tiene estipulada, si no llega a ella porque la varilla pone mucha resistencia, se queda el servo crepitando al intentar llegar y no poder. En cambio como el hilo de nicrom ofrece poca resistencia, el servo llega a su posición y no decrepita, algún chasquido aislado pero muy poco.

Yo más bien creo que el software da pulsos algo irregulares a los servos, por lo que éstos creen que se les está mandando ir a otra posición y obedecen. Si quitas los alambres y los dejas solos, sin mover nada más que su propio brazo, crepitan igual.

haute escribió:
Intentare ver si modificando el código se puede evitar que el servo siempre intente mantener la posición. Pero no se si podré.

Si lo consigues te agradecería que publicaras cómo exactamente.

haute escribió:
Si pudieras encontrar ese código que mencionas y compartirlo sería un puntazo, por cierto valdría también para 17 servos con un Arduino min pro, puedes variar la velocidad?.

Ya sé dónde está. Forma parte de mi proyecto de placa universal y sí, mueve 6 servos a velocidad lenta. Esa placa hace también de retromódulo y, por casualidad, he descubierto un molesto parpadeo en sus 8 sensores que estoy tratando de corregir sin perjudicar ni a la decodificación DCC ni al movimiento lento de los servos… Un difícil compromiso que lleva al límite al pobre Arduino. Ahí está el código de servos, entremezclado con lo otro. Ya veré cómo hago para sacarle partido. Es cuestión de encontrar el momento!
Saludos

[Multimaus + GenLi-S88 + +z21f. + RocRail (MacOsX)]
H0 Renfe, sin catenaria


Desconectado
Mensajes: 43
Registrado: 11 Feb 2014 09:47
Norber, por supuesto que si consigo algo con el código lo posteo. Respecto al crepitar de los servos, con hilo de nicrom, prácticamente no crepitan porque llegan a su posición siempre (a no ser que estén muy forzados), y solo oigo a veces 1 click cada x minutos. Pero de todas maneras miraré el código.

Respecto a la velocidad de cambio, que te pareció a ti cuando probaste el soft de Bunza?. Ya vi la placa que realizaste, quedó muy cuca de tamaño.

Esta noche pensando, se me ocurrió, sacrificar alguna salida para ganar algún boton, para poder ajustar cada servo visualmente mediante dos botones, la posición start y la stop. Y mientras estas en ese modo de ajuste, al principio todos los servos a 90, para poder colocarlos y después ajustarlos. Son ideas que no se tengo tantos conocimientos de arduino como para realizarlo.

Este método lo vi en una pcb que diseña una empresa, que usa el método de ajuste que te he comentado. A ver si encuentro el video. https://www.youtube.com/watch?v=pO1p3Gk-7TI, juraría que vi uno mejor que este ejemplo pero ahora mismo no lo encuentro.

De momento examinare el código de bunza porque es el único que tengo, pero quizás sea mejor usar un código exclusivo para servos.

Update: Respecto al crepitar, según he podido observar, no es cosa del código, ya que aunque anule por completo la función "set servo" si el servo esta forzado va a crepitar, a no ser que le quites la corriente. Creo que es cuestión de no forzar al servo y no crepita nada.
Respecto a la velocidad del servo, he modificado un poco el código y ya es mucho mas lenta. La velocidad al igual que el código original, se controla con la segunda CV de cada grupo. 1 es la mas lenta, un 4 para desvíos esta bien.
Dejo el link y lo pruebas:
https://mega.nz/#!VIhVxboQ!lPuHZF3kW5Niu_s4-_4Fcr9-rzGfb4A7cpsM6zB0BRA
Update1: He sacrificado una de las salidas, ahora solo tiene 16, para habilitar un modo de programación mediante un interruptor, en dicho modo se pondrán todos los servos al medio(90º) para su colocación en la maqueta. Y mediante un potenciometro (entrada A6) se podrán ajustar los dos momentos de parada (start y stop) del desvió. He verificado de nuevo que si no te pasas con el potenciometro forzando la fuerza con que la aguja del desvio pega a la vía, el servo no crepita y ahora estoy usando un alambre mas gordo para el vástago (el clip de aluminio).
En teoría tendría que añadir dos botones mas, uno para conmutar entre los 16 servos y otro para guardar las posiciones de cada desvió en su correspondiente CV, pero no se si lo podré lograr, ya que solo me queda una entrada analogica (A7) para los dos botones. Mas exprimido no puede estar el arduino pro mini.
Creo que es un buen método para ajustar los desvios una vez instalados, con el potenciometro.
Update2: Al final he descartado la opcion del potenciómetro y he usado 4 pulsadores conectados a la entrada analógica A7 y un interruptor de programación a la entrada A6, así respeto los 17 servos.
2 botones son para mover el servo hacia un lado y hacia otro, otro botón es para conmutar entre los 17 servos y el último botón es para programar el estado de las dos posiciones de cada servo.
Sufro de una cosa extraña y es un crepitar del servo continuo, que achaco a un mal filtraje de la señal DCC (ya que uso un 4n35 en vez de un 6n137), porque si le quito la señal DCC al arduino, el servo deja de crepitar.
Tengo que mirar si es cuestión del filtraje de la señal DCC o problema del servo, que lleva ya mucha tralla y muchas veces forzado.
Las posiciones se siguen pudiendo programar mediante CV, pero creo que el ajuste mediante botones es mas visual, mas rápido y efectivo.


Desconectado
Mensajes: 761
Ubicación: Salamanca
Registrado: 12 Ene 2012 14:44
haute escribió:
Respecto al crepitar de los servos, con hilo de nicrom, prácticamente no crepitan porque llegan a su posición siempre (a no ser que estén muy forzados), y solo oigo a veces 1 click cada x minutos. Pero de todas maneras miraré el código.

Yo llegué justamente a la conclusión contraria: es el software y no la mecánica.

haute escribió:
Respecto a la velocidad de cambio, que te pareció a ti cuando probaste el soft de Bunza?. Ya vi la placa que realizaste, quedó muy cuca de tamaño.

La velocidad siempre la encontré demasiado alta. Prefiero la solución de Paco Cañada, si no fuera porque requiere programar PIC y eso lo encuentro, ahora que he probado el Arduino, demasiado engorroso.

haute escribió:
Esta noche pensando, se me ocurrió, sacrificar alguna salida para ganar algún boton, para poder ajustar cada servo visualmente mediante dos botones, la posición start y la stop. Y mientras estas en ese modo de ajuste, al principio todos los servos a 90, para poder colocarlos y después ajustarlos. Son ideas que no se tengo tantos conocimientos de arduino como para realizarlo.

Yo soy partidario de ajustar por software todas esas cosas y por varias razones. Primero, porque ya que uno usa el ordenador con USB para volcar el código, no hay mucho inconveniente, creo yo, en volverlo a volcar cambiando los ajustes. Quizá la necesidad de hacerlo con un ordenador portátil y un cable USB largo, que llegue hasta debajo de la maqueta, pero poco más. Y segundo, porque bastará con leer el código para poder saber qué ajuste se metió, y replicarlo si hace falta en otros servos, sin tener que apuntar nada ni ir uno por uno haciéndolo con botones. Y quizá, como tercera razón, lo muchísimo que se simplifica el código si no lleva la función de programación con botones. Me gustan los códigos compactos (y elegantes).


haute escribió:
Update: Respecto al crepitar, según he podido observar, no es cosa del código, ya que aunque anule por completo la función "set servo" si el servo esta forzado va a crepitar, a no ser que le quites la corriente. Creo que es cuestión de no forzar al servo y no crepita nada.

Repito que la solución es justamente la que apuntas de la corriente, pues a mi me crepitaban los servos con el código de Bunza sin estar colocados en ningún sitio, simplemente puestos encima de la mesa. Aunque yo la expresaría de otra manera: hay que poner LOW el pin que controla al servo, sin desconectarlo de la alimentación. Eso es lo mejor y el programa de Bunza original no lo hace.

haute escribió:
Respecto a la velocidad del servo, he modificado un poco el código y ya es mucho mas lenta. La velocidad al igual que el código original, se controla con la segunda CV de cada grupo. 1 es la mas lenta, un 4 para desvíos esta bien.
Dejo el link y lo pruebas:
https://mega.nz/#!VIhVxboQ!lPuHZF3kW5Niu_s4-_4Fcr9-rzGfb4A7cpsM6zB0BRA

En cuanto tenga un hueco lo hago. Sigo escribiendo, que tu mensaje da mucho juego ;) . Ya contaré cómo van las pruebas.

haute escribió:
Update2: Al final he descartado la opcion del potenciómetro y he usado 4 pulsadores conectados a la entrada analógica A7 y un interruptor de programación a la entrada A6, así respeto los 17 servos.

Creo que te complicas demasiado, pero no cabe duda de que el objetivo es ambicioso y suena muy bien. Yo lo solucionaría, como he dicho más arriba, con un par de números al principio del programa que cualquiera puede cambiar en cuestión de segundos justo antes de volcar el programa al Arduino por última vez. Pero ánimo, que esto de programar es muy divertido y te lo estarás pasando bomba, ¿a que sí?

haute escribió:
Sufro de una cosa extraña y es un crepitar del servo continuo, que achaco a un mal filtraje de la señal DCC (ya que uso un 4n35 en vez de un 6n137), porque si le quito la señal DCC al arduino, el servo deja de crepitar.

Es mucho más barato, pero yo no he hecho aún esa prueba: siempre descodifico a través de un optacoplador 6N137. Yo investigué también por ahí, hasta que me di cuenta de que el crepitar eran imperfecciones en la duración de los pulsos de control en cada pin de cada servo: es fallo de software y no de hardware, me temo.

A ver si puedo apañar el código que tengo yo por ahí para montarlo en algún Arduino que descodifique DCC y luego lo subo a internet. Te aseguro que lo desarrollé porque el de Bunza no paraba de darme lata.
Saludos

[Multimaus + GenLi-S88 + +z21f. + RocRail (MacOsX)]
H0 Renfe, sin catenaria


Desconectado
Mensajes: 43
Registrado: 11 Feb 2014 09:47
Hola, pues si es problema de software, lo que no entiendo es porque quitando la señal DCC se para el jitter. He probado a usar la libreria "servo" y la libreria "softwareservo" que es la que usa Bunza, con un potenciometro manejando un servo y las dos van finas.
No se quizás algún tipo de incompatibilidad de la librería DCC y las librerias de servo. O de software y sincronización.
El tema del código de Bunza, tienes razón continuamente esta enviando la orden al servo, pero he modificado esa parte del código para que no realice esa instrucción cuando llega al final del recorrido y sigue crepitando. Lo mas extraño de todo esto, es que ayer no crepitaban prácticamente nada y hoy si. Ya no se que pensar si es problema de soft, incompatibilidad de librerias, arduino tocado, filtro de señal DCC al usar un 4n35 etc...
Por eso quería probar otro sketch diferente y salir de dudas.

Lo de que me lo estoy pasando bomba, bueno, es ilusionante pero a su vez decepcionante el no conseguir los resultados que esperas y encima por algo que escapa a tu control.

Lo de la botonera, es un trozo de código que puedo implementar en cualquier sketch, no cuesta mucho porque va al final del código y lo bueno es que usa las entradas A6 y A7 que no se usan.

He preguntado a Bunza por el crepitar si desconecto la señal DCC a ver que me responde.


Desconectado
Mensajes: 761
Ubicación: Salamanca
Registrado: 12 Ene 2012 14:44
Yo también le pregunté, y algún otro aficionado holandés creo recordar, y con poco o ningún éxito.
Creo que se habló de que la alimentación tenía que ser una fuente potente de 5 V cc y no el USB del ordenador, o algo así.

Yo lo paso mal, y muy mal, cuando no salen las cosas. Pero siempre salen al final. Así que debe ser que el subidón que te pega entonces compensa para seguir y seguir, con más y más proyectos, y siempre será igual: apuros hasta que sale todo. Eso me gusta, la verdad.

Tengo un montaje por ahí usado como descodificador DCC para señales de dos aspectos con encendido progresivo. Todavía no ha ido a su destino bajo la maqueta. Le cambio el código para probar servos esta tarde y te digo.
Saludos

[Multimaus + GenLi-S88 + +z21f. + RocRail (MacOsX)]
H0 Renfe, sin catenaria


Desconectado
Mensajes: 46
Registrado: 15 Jul 2013 00:41

Buenas!!! he estado leyendo y creo que tenéis el mismo problema que tenia yo, el problema es ese exactamente, que el servo hace ruido y no se esta "quieto". La verdad no se si es problema de software o de la fuente, a mi por ejemplo alimentando el Arduino desde el portátil el servo va fino, pero cuando lo monto en la maqueta no para, parece que tiene "azogue" jajajjajaja, bien para eso hay una función en la librería servo.h que se llama "dettach" y lo que hace es desligar el servo del pin que le digamos. Bien esto tiene un pro y un contra, y es que el servo se esta quieto una vez que llega a su posición por que deja de recibir señal y el contra es que cada vez que llames a ese servo tienes que ligarlo al principio de la rutina y desligarlo al final. Si le hechas un ojo a este programa http://www.infotronikblog.com/2015/10/moviendo-desvios-con-servos-y-arduino.html veras que en cada case lo ligo al principio: servo1.attach(6); y lo desligo al final: servo1.detach(); . Bueno esta solución no se si sera una "herejía" para los más sabios en programación, pero desde luego a mi me ha funcionado y como son servos que no tienen que aguantar ningún tipo de presión, como pudiera ser en modelismo al mover la dirección de un coche RC por ejemplo, va fino fino.
Por que ni poniendo un cargador de móvil conseguía quitar ese dichoso "meneito". Te animo a que lo pruebes,

Para el caso del DCC también hice lo mismo, aunque no se si he llegado a subir el código por que aun estoy poniendo los semáforos. pero es básicamente lo mismo si estas interesado en echarle un ojo dímelo y te paso el código aunque no este terminado.

Otra cosa de las que he leído es sobre los chips y piezas en general, EBAY, ahí encuentras de TODO y bastante barato, yo pille 10 6n317 por unos 3€ o incluso menos, el truco esta en mirar en EBAY.COM, si, viene de china y tarda un mes, pero es que no hay color, te gastas 10€ y compras prácticamente todo lo que te hace falta. Si miras en ebay.es hay lo mismo pero el doble o triple de caro. Lo siento por la economía de aquí, pero los precios no tienen competencia allí y normalmente los gastos de envío son gratis.

Un saludo a todos!!! espero que mi granito de arena os sea de ayuda!!!
Maqueta modular http://lamaquetade.infotronikblog.com/
Electrónica, digital y cacharreo http://www.infotronikblog.com/


Desconectado
Mensajes: 43
Registrado: 11 Feb 2014 09:47
Por el momento sigo haciendo pruebas, acabo de descubrir el culpable, y es la libreria SoftwareServo, he probado con la librería Servo y ya no hay jitter. Pero esta librería limita a 12 servos, que no está nada mal.

Revisaré si es un fallo de la librería y la actualizare o es que son incompatibles esta librería y la de DCC.
Update: la librería he puesto una nueva y pasa lo mismo, incompatibilidad de esa librería con el DCC, prueba tu con un 6n137 a ver si mejora la cosa.

Si puedo luego dejo el sketch de prueba con la librería Servo y pruebas las dos.


Desconectado
Mensajes: 46
Registrado: 15 Jul 2013 00:41

Buenas!! pues yo he probado con las dos librerías y con las dos tenia "meneillo". No es problema de compatibilidad, cada librería es para una cosa, la de DCC es para la recepción/transmisión de datos y la servo.h y softwareservo.h es para mover servo, lo unico que con la ultima no conseguí hacer el detach y con la de servo.h si.

Lo único que no he conseguido es que si esta en la posición abierto y le vuelvo a dar, no se queda donde esta, vuelve a la posición anterior y vuelve abrir, en este vídeo puedes ver lo que te digo:



También se puede ver que los servos una vez en su sitio, no vibran, se quedan parados y sin hacer ruido. El detach tiene esa "ventaja" que al dejar el servo parado, no esta consumiendo corriente, y si consume es lo mínimo, de la otra manera al estar siempre leyendo la posición siempre hay un consumo y bueno si pones un servo no tiene mucho, pero si ya tienes 5 o 6 pues como que se dispara un poco. Eso lo puedes comprobar tocando el integrado de +5 de la placa Arduino, a mi con 5 se me ponía calentito calentito, y de esta manera no.
Maqueta modular http://lamaquetade.infotronikblog.com/
Electrónica, digital y cacharreo http://www.infotronikblog.com/

ERG Avatar de Usuario

Desconectado
Mensajes: 1651
Ubicación: Blanes (Girona)
Registrado: 03 Dic 2009 21:03
Se me hace raro todos estos problemas que teneis. Yo tengo un modulo gestionado con un arduino mega que gestiona el panel con un pulsador por desvio (o uno por diagonal), todos leds bicolores, y 14 servos de tamaño standard (no me gustan los pequeños, por ruidosos e imprecisos), alimentados con una fuente de PC, y ni ruidos ni reposicionamientos ni nada de nada. Los desvios estan sin muelles (Peco), con cuerda de piano de 1mm y para nada talonables, que para eso estamos nosotros, para hacerlo bien. Eso si, no esta conectado al DCC, y aun asi tampoco entiendo que problema puede haber.

Otro rato con mas calma os pongo un resumen de mi codigo por si lo quereis probar, a ver si sigue dando esos problemas.

Enric.


Desconectado
Mensajes: 761
Ubicación: Salamanca
Registrado: 12 Ene 2012 14:44
He probado hace un rato esto que adjunto.
Es un Arduino al que le entra por el pin2 la señal DCC descodificada mediante un optoacoplador 6N137.
Sirve para 6 servos pero se puede subir a 10.
Funciona muy bien.
Lo hemos programado de cero Germán (Rfe7747) y yo.
No crepita. Probadlo a ver si os gusta ;) .

/* Arduino Nano Pro as
    - DCC accessory decoder
    - (x6) Servo controller
 Code by German Trinidad and Norber, November 2015.

 VERSION PEQUEÑA (funciona 100% pero exige direcciones por grupos de 4)
 
 Freely distributable for private, non commercial, use.
 
 Connections for DCC (adapted through 6N137 fast optocoupler):
 DCC pin 2  to  ARD pin DCC_INT
 
 Connections for accessories or servos:
 Item 1  to  ARD pin 8  (PB0)
 ...          ...
 Item 6  to  ARD pin 13 (PB5)
 */

#define DIREC1   129          // Direccion primer grupo servos:  129 son Multimaus 0005, 0006, 0007, 0008
#define DIREC2   130          // Direccion segundo grupo servos: 130               0009, 0010, 0011, 0012

#define TICKS    215          // Prescaler 8 -> pulso de Timer cada 0.5 µs -> 200 ticks son 100 µs
#define SLOTuS   6660         // Ajuste de servos (20ms / 6serv x 2000)
#define VEL_SER  5            // Lentitud del movimiento de los servos (entre 3 y 8)
#define INCR_SV  50           // Paso de servo (no cambiar)
#define DESVI    1500         // Posición desviada (cambiar de 50 en 50)
#define RECTO    4000         // Posición recta (cambiar de 50 en 50)

#define DCC_INT   2
#define SI        0            // Para el preámbulo, la primera vez de la interrupción
#define NO        1

volatile byte buf_dcc[6];      // Buffer del último comando recibido
volatile boolean comandoRecibido = false;
volatile byte servoAct = 0;
volatile int contador = 0;

struct Servos {
  byte    pinServo;
  boolean esServo;
  int     posAhora;
  int     posObjetivo;
};

Servos miServo[] = {
  {
    8, true, RECTO, RECTO}
  , {
    9, true, RECTO, RECTO}
  ,{
    10, true, RECTO, RECTO}
  , {
    11, true, RECTO, RECTO}
  , {
    12, true, RECTO, RECTO}
  , {
    13, false, RECTO, RECTO}    // Este lo configuro como señal luminosa y puebo con el LED de la placa
};

void setup() {
  pinMode(DCC_INT, INPUT);
  for (int i = 8; i < 14; i++) {
    pinMode(i, OUTPUT);
  }
  attachInterrupt(0, dcc_int, CHANGE);       // pin2 = DCC      externalInterrupt 0
  cli();
  TCCR0A = 0;
  TCCR0B = 0;
  TCCR0B |= (1 << CS01);                     // Set CS01 bit for 8 prescaler (0.5 µs) on Timer0 - DCC
  TCCR1A = 0;
  TCCR1B = 0;
  TCCR1A |= (1 << WGM11);                    // Turn on Fast PWM mode 
  TCCR1B |= (1 << WGM13)|(1 << WGM12);       // Turn on Fast PWM mode
  TCCR1B |= (1 << CS11);                     // Set CS11 bit for 8 prescaler (0.5 µs) on Timer1 - Servos
  ICR1 = SLOTuS;                             // Set PWM fixed frequency
  TIMSK1 = 0;
  TIMSK1 |= (1 << OCIE1A)|(1<<TOIE1);        // Enable Timer1 interrupts for Compare Match A & Overflow mode 
  sei();                                     // Activar interrupciones
  Serial.begin(9600);
}

void loop() {
  static byte servo, estado;
  if (comandoRecibido == true) {
    switch (buf_dcc[0]) {                    // Leo la direccion a la que se dirige el comando recibido
    case DIREC1:
      servo = 1;
      break;
    case DIREC2:
      servo = 5;
      break;
    default:
      servo = 0;
      break;
    }
    if (servo) {                                 // Si era una direccion de las mias, modifico posObjetivo
      servo = servo - 1 + ((buf_dcc[1] & 0x06) >> 1);
      estado = buf_dcc[1] & 0x01;
      if (estado) miServo[servo].posObjetivo = RECTO;
      else miServo[servo].posObjetivo = DESVI;
      if (miServo[servo].esServo == false) digitalWrite(miServo[servo].pinServo, estado);
    }
    comandoRecibido = false;
  }
}

void dcc_int() {                               // ISR(INT0_vect) External interrupt routine for signal on pin2
  static int tmp_pulso;
  static byte bit_dcc;
  static byte preamb;
  static byte aux_dcc, x_or, idx, num_bits;
  if (PIND & (0x04)) TCNT0 = 0;                                // pin2 esta HIGH
  else  {                                                      // cuando pasa a nivel bajo
    tmp_pulso = TCNT0;                                         // lee los microsegundos (byte bajo)
    if (tmp_pulso > TICKS) bit_dcc = 0;                        // duración mayor de XX us => cero
    else bit_dcc = 1;                                          // y menor uno   
    if (preamb == SI) {                                        // preámbulo
      if (bit_dcc) {                                           // otro '1'
        if (num_bits) num_bits--;
      }
      else {
        if (!num_bits) {                                       // el '0' de inicio de datos
          preamb = NO;
          num_bits = 9;
          x_or = 0;
          idx = 0;
        }
        else num_bits = 10;                                    // no se cumple la trama, vuelta a inicio
      }
    }
    else {                                                     // recepción de los bytes
      if (--num_bits) aux_dcc = aux_dcc * 2 + bit_dcc;
      else {                                                   // el separador de bytes
        if (!bit_dcc) {                                        // cero, a por el siguiente byte
          buf_dcc [idx++] = aux_dcc;
          x_or ^= aux_dcc;                                     // actualiza la x_or
          num_bits = 9;
        }
        else {                                                 // uno, fin del paquete
          preamb = SI;
          num_bits = 10;                                       // vuelta a empezar
          if (x_or == aux_dcc) comandoRecibido = true;         // paquete correcto
        }
      }
    }
  }
}

ISR(TIMER1_OVF_vect) {                                        // Timer1 Overflow interrupt for servos each 3300 µS
 static int sumar, dif;
 if (contador == VEL_SER) {
 //if ((contador == VEL_SER) && (miServo[servoAct].esServo == true)) {
   sumar = 0;
   dif = miServo[servoAct].posAhora - miServo[servoAct].posObjetivo;
   if (dif < 0) sumar = INCR_SV;
   else if (dif > 0) sumar = -INCR_SV;
   if (sumar) {
     if (miServo[servoAct].esServo) digitalWrite(miServo[servoAct].pinServo, HIGH);
     miServo[servoAct].posAhora += sumar;
     OCR1A = miServo[servoAct].posAhora;
   }
 }
 else contador++;
}

ISR(TIMER1_COMPA_vect) {                                     // Timer1 Match Compare A interrupt for servos
  if (contador == VEL_SER) {
    if (miServo[servoAct].esServo) digitalWrite(miServo[servoAct].pinServo, LOW);
    if (++servoAct > 5) {
      servoAct = 0;
      contador = 0;
    }
  }
}
Última edición por Norber el 25 Ene 2016 08:39, editado 1 vez en total
Saludos

[Multimaus + GenLi-S88 + +z21f. + RocRail (MacOsX)]
H0 Renfe, sin catenaria


Desconectado
Mensajes: 43
Registrado: 11 Feb 2014 09:47
Peyu: Respecto al tema de jittering, antes de nada deberías de alimentar los servos con una fuente externa, una de un PC como ha comentado ERG es buena idea, esto quita mucho de jittering. No se que sketch estas usando si el de Bunza y otro, pero el de Bunza, por lo que he podido probar hasta ahora, sufre de jittering a mi juicio por una incompatibilidad de la librería Softwareservo.h y la DCC. Porque he cambiado la librería por la de servo.h y ya no tengo jittering, lo malo es que solo puede manejar 12 servos esta librería. Si estas usando la librería servo.h prueba a alimentar los servos con una fuente externa potente, veras como cambia el tema. Yo al principio tenia un jittering de escándalo y era por conectar tan solo 2 servos al arduino.
Si estas usando el código de Bunza, podrías poner donde y como realizas el detach?.
Por lo demás el código de Bunza esta bien , ya que permite otras configuraciones y velocidades individuales para cada servo, aunque no lo lentas que deberían, para eso he modificado un poco el código.

A ver si entre mañana y pasado saco un rato y termino el código, eso si, solo 12 servos, menor velocidad y ajuste del servo con pulsadores y CV y espero 0 jittering.

ERG: El funcionamiento de los servos depende bastante del código y tiempos, puede ser influenciado por otras librerias. Tu código quizás sea menos exigente, aunque nunca se sabe.

Podrías recomendar esos servos mas grandes que usas? que marca son y donde los compras? son de engranajes metálicos?

Yo he pedido unos a hobbyking de los pequeños a 2€ y poco. A ver como salen. Actualmente tengo dos TowerPro 9g.(que dudo que sean originales)

Norber: Por supuesto que lo probaré, gracias, por cierto probaste el que subí?, seguramente crepitaría un poco, pero si haces l prueba de quitarle la señal DCC se para, haz la prueba.


Desconectado
Mensajes: 46
Registrado: 15 Jul 2013 00:41

Buen Domingo a todos!!!
Haute, tengo una fuente de PC que usaba en mi otra maqueta y es cierto que nunca tuve problemas con la alimentación. Por desgracia tuve que desmontarla y por eso empece con la modular. Bien cada modulo (o cada par) llevan un par de transformadores de 15v alterna 1A. Evidentemente filtro la corriente con varios condensadores, puente de diodos y 7805 o 7812 según lo que alimente.
Lo de las librerías ya me pones en duda, aunque sigo pensando que no tiene nada que ver (por dar polemica jajajaja), pero viendo tu nivel de programación supongo que sera así, ademas la Softwareservo.h la he tocado muy poco.
La librería que utilizo es la DCC_Decoder.h que encontre en http://www.mynabay.com/ pero también he utilizado la de NmraDcc.h con buenos resultados. ¿donde puedo conseguir el código Bunza para probarlo?
Mi código es más bien básico, ya que no se puede programar mediante CVś, pero bueno cumple su función, además como máximo tengo 5 o 6 servos por modulo y un Arduino por módulo, con lo que me sobran pines para poder hacer otras cosas como el tema de las luces que se puede ver en el primer vídeo que subí.
Aquí os dejo el código completo:

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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 23 y 44 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
int dir;
Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
const byte maxservos = 4; //Numero de servos que hay conectados a este Arduino.
const byte servoTimer = 20; //Tiempo de cambio de angulo del servo. A menor valor -> mayor velocidad.
const byte servoDoor = 50;
//Servo1******
int servoVarMin1=50;  //Valor minimo del servo2
int servoVarMax1=95;  //Valor maxi del servo2
int servoVar1;
//Servo2******
int servoVarMin2=50;  //Valor minimo del servo2
int servoVarMax2=120;  //Valor maximo del servo2
int servoVar2;
//Servo3******
int servoVarMin3=65;  //Valor minimo del servo2
int servoVarMax3=100;  //Valor maximo del servo2
int servoVar3;
//Servo4******
int servoVarMin4=0;  //Valor minimo del servo2
int servoVarMax4=100;  //Valor maximo del servo2
int servoVar4;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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.println(enable);

  switch (address){
  case 1:
    servo1.attach(4);
    if (enable){
      for(servoVar1 = servoVarMin1; servoVar1 <= servoVarMax1; servoVar1 += 1){                                 
        servo1.write(servoVar1);   
        delay(servoTimer);
      }
      digitalWrite (8, HIGH);
    }   
    else {
      for(servoVar1 = servoVarMax1; servoVar1 >= servoVarMin1; servoVar1 -= 1){                                   
        servo1.write(servoVar1);             
        delay(servoTimer); 
      }
      digitalWrite(8,LOW);
    }
    servo1.detach();
    break;
  case 2:
    servo2.attach(5);
    if (enable){
      for(servoVar2 = servoVarMin2; servoVar2 <= servoVarMax2; servoVar2 += 1){                                 
        servo2.write(servoVar2);   
        delay(servoTimer);       
      }
      digitalWrite (9, HIGH); 
    }   
    else {
      for(servoVar2 = servoVarMax2; servoVar2 >= servoVarMin2; servoVar2 -= 1){                                   
        servo2.write(servoVar2);             
        delay(servoTimer); 
      }
      digitalWrite(9,LOW);
    }
    servo2.detach();
    break;
  case 3:
    servo3.attach(6);
    if (enable){
      for(servoVar3 = servoVarMin3; servoVar3 <= servoVarMax3; servoVar3 += 1){                                 
        servo3.write(servoVar3);   
        delay(servoTimer);
        Serial.println("aqui llega");       
      }
      digitalWrite (10, HIGH); 
    }   
    else {
      for(servoVar3 = servoVarMax3; servoVar3 >= servoVarMin3; servoVar3 -= 1){                                   
        servo3.write(servoVar3);             
        delay(servoTimer); 
      }
      digitalWrite(10,LOW);
    }
    servo3.detach();
    break;
  case 4:
    servo4.attach(7);
    if (enable){
      for(servoVar4 = servoVarMin4; servoVar4 <= servoVarMax4; servoVar4 += 1){                                 
        servo4.write(servoVar4);   
        delay(servoDoor);       
      } 
    }   
    else {
      for(servoVar4 = servoVarMax4; servoVar4 >= servoVarMin4; servoVar4 -= 1){                                   
        servo4.write(servoVar4);             
        delay(servoDoor); 
      }
    }
    servo4.detach();
    break; 
  case 5: 
  if (enable){
    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);
    }
  }
    else {
      digitalWrite (11, LOW);
    }
}
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// configuracion (se ejecuta una vez)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
  Serial.begin(9600);
  DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);

  servo1.attach(4);    //Adjuntamos el pin 4 a servo1
  servo1.write(servoVarMin1);
  delay(500);
  servo2.attach(5);    //Adjuntamos el pin 5 a servo2
  servo2.write(servoVarMax2);
  delay(500);
  servo3.attach(6);    //Adjuntamos el pin 6 a servo3
  servo3.write(servoVarMin3);
  delay(500);
  servo4.attach(7);    //Adjuntamos el pin 7 a servo4
  servo4.write(servoVarMax4);
  servo1.detach();
  servo2.detach();
  servo3.detach();
  servo4.detach();
  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);
  pinMode(9,OUTPUT);
  pinMode(10,OUTPUT);
  pinMode(11,OUTPUT);
  digitalWrite(8,LOW); //Led apagado al empezar
  digitalWrite(9,LOW); //Led apagado al empezar
  digitalWrite(10,LOW); //Led apagado al empezar
  digitalWrite(11,LOW); //Led apagado al empezar

}

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

void loop()
{

  DCC.loop(); // Libreria DCC
}


Saludos!!!
Maqueta modular http://lamaquetade.infotronikblog.com/
Electrónica, digital y cacharreo http://www.infotronikblog.com/

ERG Avatar de Usuario

Desconectado
Mensajes: 1651
Ubicación: Blanes (Girona)
Registrado: 03 Dic 2009 21:03
Utilizo una libreria llamada VarSpeedServo.h, que lo que consigue es poder ajustar la velocidad a nuestro gusto. Si no funciona la libreria por que el IDE de Arduino es actual, cambiad Wprogram.h por Arduino.h dentro de la libreria, por que creo que ese zip esta tal cual lo descargue.

En el ejemplo se pueden conectar 2 pulsadores (uno por servo) y dos servos, pero se puede tantos como permita la placa.

En el video adjunto, se ve (y no se oye, solo habla el gato) como los servos se mueven a la velocidad que me gusta, ademas se pueden mover varios a la vez. Por mucho que pulse, el servo ejecuta la orden hasta el final, y no vuelve si esta a medio camino.

Al final del video se ve como obligo el servo con los dedos y se oye como el quiere mantener la posicion, pero moviendo la varilla, ni se inmuta.

El soporte blanco, lo he diseñado yo y hecho imprimir en 3D, e incluye un microruptor para poder polarizar el desvio sin tener que necesitar mas electronica, reles, etc. El servo es standard, de 3€ en Hobbyking Europa (ref. 15138)

Adjunto la libreria (por que he visto que hay alguna mas que se llama igual pero no es identica) y el codigo para que probeis.

Espero que sea de ayuda.

Enric.


#include <VarSpeedServo.h>

const byte num_servos = 2;

VarSpeedServo servos[num_servos];

// pin pulsador, pin servo, posicion recto, posicion desviado, ultima posicion, boton pulsado
int pulsador_servo[2][6] = {
  {
    2, 3, 60, 103, 60, 0
  }
  ,
  {
    7, 9, 60, 103, 60, 0
  }
};

void setup()
{
  for (int servo_num = 0; servo_num <= num_servos - 1; servo_num++) {
    servos[servo_num].attach(pulsador_servo[servo_num][1]);
    servos[servo_num].slowmove(pulsador_servo[servo_num][2], 10);
  }
}

void loop()
{
  for (int servo_num = 0; servo_num <= num_servos - 1; servo_num++) {

    pulsador_servo[servo_num][4] = servos[servo_num].read();
    pulsador_servo[servo_num][5] = digitalRead(pulsador_servo[servo_num][0]);

    if (pulsador_servo[servo_num][5] == HIGH  && pulsador_servo[servo_num][2] == pulsador_servo[servo_num][4]) {
      servos[servo_num].slowmove(pulsador_servo[servo_num][3], 10);
    }

    if (pulsador_servo[servo_num][5] == HIGH  && pulsador_servo[servo_num][3] == pulsador_servo[servo_num][4]) {
      servos[servo_num].slowmove(pulsador_servo[servo_num][2], 10);
    }
  }
}



Adjuntos
VarSpeedServo.zip
(7.91 KiB) 172 veces


Desconectado
Mensajes: 43
Registrado: 11 Feb 2014 09:47
Hola, el código Bunza lo tienes aquí, así como pcb para su uso.
http://model-railroad-hobbyist.com/node/24316

Es curioso, todos usáis librerias DCC de otros, no la oficial de l NMRA. Bueno Norber incluso se atreve a no usar librería, eso implica muchos mas conocimientos del protocolo DCC.
Yo probé otro código que circula por internet que usaba otra librería a la oficial y me fallaba mucho, así que desistí ese código. creo que fué este:https://rudysmodelrailway.wordpress.com/software/.

Mañana si tengo un rato pruebo los sketch.


Desconectado
Mensajes: 761
Ubicación: Salamanca
Registrado: 12 Ene 2012 14:44
En efecto. Usar librerías ya hechas, es decir, subrutinas que se reaprovechan en un programa general, tiene la ventaja de ahorrar tiempo si son buenas y está claro cómo funcionan. Pero al no saber qué hacen exactamente se puede uno encontrar con fenómenos indeseados.

Mover servos requiere una técnica muy exacta en el cálculo de la longitud de los micropulsos que constituyen la señal de control. Si no se consigue esa exactitud es muy posible que los servos se muevan ligerísimamente todo el tiempo (el crepitar que se oye) alrededor del supuesto punto en que deben estar. De ahí la necesidad de desconectarlos en cuanto han llegado.

Si solo se mueven a la orden de un pulsador, como en la solución de ERG (por cierto, la que realmente corresponde al título de este hilo), cualquier solución es buena. Pero si además de mover servos con precisión es necesario descodificar la señal DCC, porque se gobiernan desde la central, entonces la cosa se complica y aparecen los fallos.

Como yo necesitaba ambas cosas (descodificar DCC y mover al menos 6 servos a la vez) probé también todas las subrutinas que encontré, incluida la que aporta Peyu, de Ruud Boer traducida por Carlos Muñoz, que es la misma indicada por haute en el enlace anterior (https://rudysmodelrailway.wordpress.com/software/.) Ninguna me satisfizo por cuestiones varias, por lo que al final me puse manos a la obra y el primer resultado ya lo podéis probar. En efecto, no usa 'librería' de nadie, descodifica con la técnica de Germán Rfe7747, y es el código más compacto que he visto, algo que también necesitaba para otro proyecto todavía en curso.
Saludos

[Multimaus + GenLi-S88 + +z21f. + RocRail (MacOsX)]
H0 Renfe, sin catenaria


Desconectado
Mensajes: 2277
Registrado: 21 Mar 2014 12:52
Hola.

Norber, Germán, estoy revisando vuestro precioso código y me surgen algunas dudas.

Veo que leéis el pin 2 utilizando el registro PIND que es más rápido que usar un DigitalREAD.

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

¿podéis pasarme un enlace sobre este uso que hacéis?

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

void loop() {
  if (comandoRecibido == true) {
    escribir el paquete recibido dispuesto de forma legible (y posiblemente en Hex)
  }
  comandoRecibido = false;
}


Gracias.


Desconectado
Mensajes: 43
Registrado: 11 Feb 2014 09:47
Hola, primero dar las gracias a Peyu y ERG por vuestros aportes, de momento solo he podido probar el sketch de Peyu y la verdad es que la librería DCC me funciona mejor que la pagina que mencione y me sorprende porque en teoría es la misma librería. Los servos funcionan bien, solo hay una pega y es que si le doy al mismo lado, el servo vuelve a su otra posición y después vuelve a la original, en vez de quedarse quieto. Por otro lado, no puedes hacer que cambie de posición mientras se esta efectuando un movimiento, hay que esperar a que llegue al final.
Del sketch de ERG la novedad es la librería VarSpeedServo.h que tengo que darle un ojo con mas detenimiento. 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?

Respecto al sketch de Norber, lo he intentado, pero no acierto a hacerlo funcionar por un tema de la asignación de la address, me explico. Para hacer todas estas pruebas, uso un Sprog3 como command station para enviar las ordenes DCC.
En el skecth de Bunza, la address del Decoder de accesorios empieza en 40, con lo cual el siguiente servo sería 41 y así sucesivamente. En el sketch de Peyu empezaba en el 1.
Pero en el skecth de Norber no he sido capaz. Y es aquí donde lanzo varias dudas respecto a esto y Multimouse.

En Multimouse, cuando añadimos un decoder de accesorios, el multimouse, si es el primero, lo configura con las direcciones 1 a 4 y después 5 a 8. Pero internamente ese decoder que adress tiene?.
Por ejemplo, supongamos que quiero usar el skect de Bunza que empieza en 40, pero que puedo poner cualquier dirección. Imaginemos que ya tengo 2 decoders de accesorios instalados en el multimouse, 1 decoder (1 a 4 y de 5 a 8), 2 decoder (9 a 12 y 13 a 16), que numero tengo que poner en el skecth de Bunza para que el multimouse lo reconozca desde el 17 en adelante?.

La correspondencia Multimouse-Rocrail con las tablas que publicaste me quedo claro, pero el como configura el multimouse un decoder de accesorio no lo tengo claro. No se si el propio multimouse cambia las adress o las interpreta.

Para testear los sketch normalmente uso el JMRI, el cual pongo en el desvió la address ( 40 en el de bunza para el primer servo) y listo, 41 el segundo y así sucesivamente. Para tu skecth Norber ni idea que poner.

Respecto al skecth, estoy optando de momento por una versión del de Bunza de solo 12 servos. (Con librería servo.h) que va fina. A falta de añadir los pulsadores, no se si gastando el resto de entradas, o usando los 5 pulsadores por las entradas A6 y A7 y dejando el resto de salidas para leds o reles. Estoy en ello, cuando tenga algo claro lo posteo. Una ventaja del codigo de Bunza es la posibilidad de usar velocidades de servo independientes, programacion mediante CV, y poder usarlo no solo para servos, sino para leds, reles etc... pero como bien habéis comentado, a códigos mas complicados mas errores y posibilidad de fallos.

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

AnteriorSiguiente

Volver a Digital, Electricidad e Informática

Síguenos en Facebook Síguenos en Youtube Síguenos en Instagram Feed - Nuevos Temas
©2017   -   Información Legal
cron