Calificación:
  • 0 voto(s) - 0 Media
  • 1
  • 2
  • 3
  • 4
  • 5
[WORKLOG][PROYECTO]ECO-Cablecam GOPRO
#1
Muy buenas. Se presenta este proyecto con la colaboración de quien lo desee, por el momento adscritos al proyecto y participando en el:
Mr.Proper
Biketrial981

Lo que se quiero es esto pero en formato económico pero potente.




https://youtu.be/MMopfrG5j7g

Presentación proyecto:
Construir un cablecam con materiales económicos y que cualquiera pueda tener acceso a el, a su vez que sea completamente funcional automatizada y con giro de 360º para las cámaras tipo GoPro. Con dos tipos de control manual y programable para TIMELAPSE. También sera de fácil montaje y puesta en marcha sobre el cable, sin necesitar ninguna herramienta para elllo. De reducido tamaño y peso para un transporte fácil.
Y lo mas importante, sera controlado por wifi con servicio multiplataforma, para así no necesitar emisoras ni receptores


Composición Proyecto:

En su parte física, estará realizada 100% en abs o pla imprimible desde cualquier impresora, así se economizara en costes de mecanizado y reduciendo el peso.

En su parte mecánica costara de 4 rodamientos tipo carro de extrusor de nuestras impresoras y un rodamiento tipo polea de las impresoras, dado que son fáciles de encontrar en muchas tiendas y a bajo coste.

En su parte electronica, estará compuesta para su control por un arduino YUN, un pololu, un motor tipo nema17, lipo 3s 11.2v y un servo tipo s3003 (trucado a 360º) para la rotación de la cámara. He elegido esta composición por lo mismo, es fácil de encontrar muchos lo comercializan y por tanto encontraremos buen precio.




resim
resim
resim
resim
resim

Realizado hasta el momento:

Parte FÍSICA: diseñado e impreso de todo el conjunto, algunas piezas re-diseñadas para un ajuste de varios componentes.
Parte MECÁNICA: rodamientos, poleas y engranajes comprobado que encajan y alineado de poleas correcto.
Parte ELECTRÓNICA: motor, servo y arduino comprobado que encajen y hagan su función y movimientos correctamente.

Tareas pendientes:
Programación de arduino yun, tanto para control remoto como programado timlapse, control de motor y servo (gracias por ofrecerte Biketrial981)
Servidor web multiplataforma para acceso y control del cablecam.

Mejoras:
Una vez realizado todo lo pendiente, en una segunda versión nos gustaría incluir el control de till para un gimball


Si os unís al proyecto podríamos sacar algo realmente atractivo y con el sello SPAINLABS.
Citar
#2
bueno pues despues de varios rediseños ya tengo todo imprimido y montado.
resim
resim
resim
resim

y ya me pongo con la electronica y el skech de arrduino.

primero la electronica este es el esquema, me podriais echar un vistazo para ver si es correcto?

es que tengo dudas con cargar el +5v de arduino para alimentar el pololu, servo y el hc-5

resim
gracias.

una vez resuelto esto tambien tengo dudas con el programa de arduino pero eso mas tarde jejejeje y por supuesto una vez terminado todo lo colgare en thingiverse para todo el que quiera.
Citar
#3
Muy original, parece que no pero interesa, aunque la gente no comente mucho.

Saludetes
Edu
Citar
#4
Buenas! pues precisamente estaba liado ahora mismo con un proyecto similar.... un slider para timelapse con los chicos de PA por un intercambio de trabajos xD

Tengo dominados los nema con velocidad, pasos e incluso aceleraciones y deceleraciones, y muy controlado el arduino yun, por lo que me encargaron este proyecto.

Si quieres hacerlo más sencillo en cuanto a interface, te recomiendo hacerlo con un yun. La interface será web, por lo que no tienes que hacer app para distintos sistemas (ios, android, pc etc...), tienes wifi, puedes incluso controlar la gopro por wifi con una librería que hay... es una pasada.

Yo tengo todo montado y funcionando, estoy terminando la interface de control.

Cuando llegue a casa cuelgo unas capturas, pero si necesitas ayuda... Guiño

Otra cosa, tienes publicados los archivos para echarles un ojo?


Salu2!

PD: no puedes alimentar todo eso no de broma con el arduino... el ardu es solo para señales. Tienes que alimentar todo desde la batería, arduino incluido, y lo que va a 5V poner un beq de 5V
Citar
#5
ya me imaginaba yo..... el hc-5 si que lo he alimentado desde el arduino y funciona bien pero sumarle el servo y el pololu.......

en cuanto a lo del yun, pues si estaria genial pero no controlo tanto la verdad, una pena por que parece realmente interesante y ya lo de la gopro y todo ufffffff

los archivos aun no los tengo subidos hasta no terminar todo, ya que puede sufrir cambios mas que nada pero si quieres te puedo pasar lo que tengo.
Citar
#6
Por lo del no controlar con el yun no hay problema, yo me sumo al proyecto sin fallo Guiño

Lo digo por que da mucha chicha al asunto.... y una vez empiezas es muy fácil, no deja de ser un arduino.

De hecho yo tengo el firmware y la web de control 100% funcional para timelapse (y empezado ya el control del servo ya que quiero meterle también paneo).

Si se nos sumara alguien que controle un mínimo de html y o bien js, ajax o jquery podríamos hacer un pepino increíble.
Yo algo controlo de web pero lo justo. Para hacerlo funcional pero sin florituras visuales, y hay unas librerías para sliders, botones y gui en general muy potentes xD

Salu2!

PD: pásame los archivos que tengas y los imprimo y vamos viendo como funciona Guiño
Citar
#7
ok pues perfecto. lo organizamos y vemos que sale de todo esto.
comprare un yun ya que no tengo.
https://dl.dropboxusercontent.com/u/497/ECOCABLECAM.rar

Aqui esta, si tienes o teneis dudas decirlo, para modificar algo pues también que tardo poco
Citar
#8
por cierto.................. jodooo con el yun no? 74 jureles?
Citar
#9
xD

No es caro para lo que ofrece.... mira la shield wifi:

http://tienda.bricogeek.com/home/446-ard...ld-sd.html

El yun trae:

- arduino
- Linux
- Servidor web
- Wifi
- Sd
- Usb host
- Streaming de webcam
- etc...

De primeras puede parecer caro, pero lo que se aprende con el no tiene precio jajajaja. Además, tener las mismas funcionalidades en un arduino con shields cuesta el doble.

De todas formas, si se decidiera usar el yun (mejor solo trabajar con un sistema ya que cambia todo el código), te puedo ayudar a conseguir uno a buen precio Guiño

Date cuenta el tiempo que se ahorra en programación, hacerlo multiplataforma, e incluso para ampliaciones futuras.

Es completamente viable con un arduino y bluetooth, pero creo que es lo ideal para este proyecto ;-P


Salu2!
Citar
#10
Pues nada nos pasamos al yun, ya me dirás como conseguir ese yun jejejeje

Lo de arduino y btt era por el tema económico, pero si por contra conseguimos mas opciones, multiplataforma y demás pues las ventajas ganan.
Asi que eco_cablecam + yun.

modifico el tema inicial.
Citar
#11
Yo tenía unos bocetos de algo similar para las go pro, pero no tengo tiempo a más, xD.

Una cosa. Has probado a colgarlo ya¿? está equilibrado¿? al colgar el motor de un lado, tendrás que poner contrapesos en el lado donde está el ardu (o en el "columpio" para la cámara).

P.D.: Un yun como te dice bike es lo propio para esto.
Citar
#12
Que problemas encontraste con accelstepper.h?

A mi me funciona muy bien, tanto velocidades como aceleraciones.

Hay algunos parámetros que funcionan solos, y otros que hay que utilizarlos con una llamada run para que esté ejecutandose.

Te dejo el ejemplo que tengo yo para probar los drivers y los motores

Con run:
Código:
#include <AccelStepper.h>

AccelStepper stepper(1, 11, 12);

void setup()
{  
   stepper.setMaxSpeed(4000);
   stepper.setSpeed(1500);
    
}

void loop()
{  
   stepper.moveTo(1600);
   stepper.run();

}

y directo, que es como mejor van:

Código:
#include <AccelStepper.h>

int intervalo = 1000;
int velocidad = 2000;
int aceleracion = 600;
unsigned long var = 0;

AccelStepper stepper(1, 11, 12);

void setup()
{  

}

void loop(){
    
    stepper.setMaxSpeed(velocidad);
    stepper.setAcceleration(aceleracion);
      
for (unsigned long var = 0; var <= 60000; var= var + 800){
  //delay(intervalo);
    stepper.runToNewPosition(var);
    Serial.println(var);
      }
      delay(intervalo);
}
Citar
#13
pues lo miro a ver como va y te digo..... aunque como te comento no ando muy pez en esto Facepalm Facepalm

Jukillo si ya lo colgué y estaba equilibrado en el lado de la electrónica esta la lipo y compensa una cosa con otra, aunque las varillas de 8 de las poleas que a la vez unen todo, ya tenia pensado alargarlas al lado de la electrónica para colocar un contrapeso de manera fina.

Con los últimos cambios si que se tuerce un poco al lado del motor ya que las poleas las desplace un poco, pero tengo que re-diseñar los espaciadores ya que creo que un par de milímetros puedo ganar y así queda mas centradas las poleas y por tanto menos cabecea.

Esta semana ya me quería poner con el tema arduino, pero ahora con el cambio a yun tengo que empaparme y esperar a bikertrial jejejeje

por cierto subo el nuevo repositorio, que el anterior tenia algunos archivos viejos, lo siento.....

https://dl.dropboxusercontent.com/u/477/ECOCABLECAM.rar
Citar
#14
El lunes vemos lo del yun Guiño

Por el resto, voy a limpiar y comentar un poco el código ya que no tiene ni el primer comentario, y lo adapto a ojo para nuestras necesidades.

Habría que definir bien que movimientos o controles necesitamos para una V1 y después vemos que mejorar.

Entiendo que necesitamos X campos de config y un botón para iniciar.

Hay parámetros que hasta que lo tenga montado no podremos hacer los cálculos, como por ej sin saber los mm/paso que tenemos de movimiento. Al tener este parámetro es solo modificar los cálculos que tengo en mi firmware.

Por ej, yo tal y como lo tengo desarrollado lo que le doy para un timelapse por ej es:

- Punto de inicio (en mm)
- Punto final (en mm)
- Nº de fotos
- Intervalo entre fotos (en milisegundos)
- retraso de inicio (en minutos)

Y el solo ya calcula los pasos entre fotos y demás que necesita.

A mayores de esos parámetros, que se introducen desde la web, tengo varios en el firmware a pelo, pero que quiero que se cambien desde la web y guardarlos en la eeprom, ya que se cambiarán poco.

Estos son:

- Velocidad de movimiento en timelapse
- aceleración y deceleración entre movimientos
- tiempo de exposición de la foto
- velocidad de homming (podemos poner un homming por efecto hall con un prisionero metálico en el cable)

Y alguno más que se me escapa.... Guiño

También tengo implementado el ir al punto de inicio, ir al punto final, ir al home y un reset del arduino desde la web.

Por esa parte no te preocupes, que en cuanto tenga un modelo para pruebas, tenemos web y firmware V1 para pruebas en unas horas jajajaja.
Tengo aquí nema, pololu, yun, lipos... no tengo que comprar nada que no sea el cable.
Por cierto, para que ancho de cable está diseñado este y que tipo tienes pensado usar?

Deberíamos de definir bien los parámetros que queremos tener, y yo con eso voy ya adaptando lo que tengo, lo comento un poco y empezamos todos a trabajar sobre una V1 funcional.


Venga que esto lo hacemos en 0,5! :elrisas:

PD: imprimiendo el soporte de motor Mola

Otra duda, aunque rompa el diseño original.... por que no hacerlo brushless? el nema mas pequeño que tengo aquí son 172.5g contra los 50 de los brushless que uso, además del tamaño y poder centrar mejor el peso, así como más velocidad.

Ya por lo liarla con algo así xD

http://www.flyingfoxcam.com/#!flyingfoxcam/c179p

Los brushless se controlan como servos, son muy fáciles de manejar aunque algo menos imprecisos comparados con un pap
Citar
#15
Os dejo la base del código que utilizaremos para que la vayáis leyendo y entendiendo.

Si, ya se que mi código hace llorar al niño jesús, pero es funcional xD

Se aceptan críticas, sugerencias y demás :elrisas: :elrisas: :elrisas:

Código:
// Cable-CAM SL V 0.1
// Realizado por Mr.Propper y biketrial981


//incluimos las librerías necesarias

#include <SoftwareSerial.h>
#include <Bridge.h>
#include <Servo.h>
#include <YunServer.h>
#include <YunClient.h>
#include <AccelStepper.h>

//Declaramos nuestro motor en los pines 11 y 12, y enable en el 1 aunque no lo usaremos
AccelStepper stepper(1, 11, 12);

//Declaramos las variables a utilizar en el sketch como unsigned long para evitar desbordamientos.
//Utilizaremos T_ para timelapse, V_ para vídeo y C_ para comunes y configuraciones
unsigned long T_inicio = 0;
unsigned long T_final = 0;
unsigned long T_fotos = 0;
unsigned long T_intervalo = 0;
unsigned long T_retardo = 0;
unsigned long T_velocidad = 4000;
unsigned long T_aceleracion = 1500;

unsigned long T_pasos = 0;
unsigned long T_mover = 0;

unsigned long V_pasos = 0;

unsigned long V_inicio = 0;
unsigned long V_final = 0;
unsigned long V_aceleracion = 0;
unsigned long V_velocidad = 0;
unsigned long V_retardo = 0;

//unsigned long estado = stepper.currentPosition();

//declaramos las variables de selección de modo

int variableT = 0 ;
int variableV = 0 ;

//declaramos el pin para el endstop de homming

const int homeButton = 2;
byte hBval;

//Declaramos las variables sobre las que calcularemos los pasos a mover en los distintos modos.

unsigned long Tvar = 0;
unsigned long Vvar = 0;

//activamos el servidor en el yun
YunServer server;

void setup() {

  //Pin 3 como salida, lo usaremos para el disparador cableado o para
  //led de señalización. Iniciamos en low

  pinMode(3,OUTPUT);
  digitalWrite(3, LOW);

  //Pin 2 como entrada para endstop

  pinMode(2,INPUT);

  //Iniciamos el bridge del yun, el serial a 9600 y el server.

  Bridge.begin();
  Serial.begin(9600);
  server.begin();

  //ejecutamos el bloque Pinicio para que haga homming en el primer arranque.
  //Comentar para desactivar función homming en el inicio, aunque podemos ejecutarla via web.

  Pinicio();
}

void loop() {

  //comprobamos si hay cliente conectado

  YunClient client = server.accept();
  if (client) {
    process(client);
    client.stop();
  }
  delay(50);
}
//procesamos el primer string del cliente, entre las primeras barras (/arduino/**string**/)
//y llamamos al bloque correspondiente

void process(YunClient client) {
  
  String command = client.readStringUntil('/');
  
    if (command == "timelapse") {
      Timelapse(client);
  }
    if (command == "video") {
      Video(client);
  }
    if (command == "config") {
      Config(client);
  }
    if (command == "Vstart") {
      Vstart(client);
  }
    if (command == "Tstart") {
      Tstart(client);
  }
    if (command == "inicio") {
      Inicio(client);
  }
    if (command == "final") {
      Final(client);
  }
    if (command == "home") {
      Home(client);
  }
}

// |- - - - - - - - - - - - - -|
// |                           |
// | ** bloque de Timelapse ** |
// |                           |
// |- - - - - - - - - - - - - -|

//procesamos el segundo string del cliente, entre las segundas barras (/arduino/timelapse/**string**/)
//y lo vamos parseando y grabando en las variables para los cálculos al lanzar el start.

void Timelapse(YunClient client) {
  
variableT = client.parseInt();

if (variableT == 1){
  
    if (client.read() == '/') {
      T_inicio = client.parseInt();
    }
  }
if (variableT == 2){
    if (client.read() == '/') {
      T_final = client.parseInt();
    }
  }
if (variableT == 3){
    if (client.read() == '/') {
      T_fotos = client.parseInt();
    }
  }
if (variableT == 4){
    if (client.read() == '/') {
      T_intervalo = client.parseInt();
    }
  }
if (variableT == 5){
    if (client.read() == '/') {
      T_retardo = client.parseInt() * 60.000;
    }
  }  
}

// |- - - - - - - - - - - - - -|
// |                           |
// |   ** bloque de Vídeo **   |
// |                           |
// |- - - - - - - - - - - - - -|

//procesamos el segundo string del cliente, entre las segundas barras (/arduino/video/**string**/)
//y lo vamos parseando y grabando en las variables para los cálculos al lanzar el start.

void Video(YunClient client){
  
variableV = client.parseInt();

if (variableV == 1){
    if (client.read() == '/') {
      V_inicio = client.parseInt();
    }
  }
if (variableV == 2){
    if (client.read() == '/') {
      V_final = client.parseInt();
    }
  }
if (variableV == 3){
    if (client.read() == '/') {
      V_aceleracion = client.parseInt();
     }
   }
if (variableV == 4){
    if (client.read() == '/') {
      V_velocidad = client.parseInt();
    }
  }
if (variableV == 5){
    if (client.read() == '/') {
      V_retardo = client.parseInt() * 60.000;
    }
  }  
}

// |- - - - - - - - - - - - - -|
// |                           |
// |   ** bloque de Config **  |
// |                           |
// |- - - - - - - - - - - - - -|

//procesamos el segundo string del cliente, entre las segundas barras (/arduino/config/**string**/)
//por el momento solo imprimimos la config por el serial del estado actual de todas las variables

void Config(YunClient client){

Serial.println("--Timelapse--");
Serial.println(T_inicio);
Serial.println(T_final);
Serial.println(T_fotos);
Serial.println(T_intervalo);
Serial.println(T_retardo);
Serial.println("----------");
Serial.println("--Video--");
Serial.println(V_inicio);
Serial.println(V_final);
Serial.println(V_aceleracion);
Serial.println(V_velocidad);
Serial.println(V_retardo);
Serial.println("----------");
Serial.println(" ");  
}

// |- - - - - - - - - - - - - -|
// |                           |
// |   ** Inicio de Video **  |
// |                           |
// |- - - - - - - - - - - - - -|

//Bloque llamado al inicial el vídeo, donde haremos todos los cálculos y enviaremos los movimientos.
//Al iniciar enviamos la config actual por el serial.

void Vstart(YunClient client){

String frase1 = "Video Iniciando a ";
  String frase2 = frase1 + V_inicio;
  String frase3 = frase2 + " mm de inicio, hasta " + V_final;
  String frase4 = frase3 + " mm del final, a una velocidad de " + V_aceleracion;
  String frase5 = frase4 + " pasos/segundo con aceleracion de " + T_intervalo;
  Serial.println(frase5 + " pasos/segundo");

stepper.setMaxSpeed(V_velocidad);
stepper.setAcceleration(V_aceleracion);

unsigned long V_pasos = (V_final - V_inicio) * 80;

//Serial.println("Vamos a punto de inicio");  
stepper.runToNewPosition(V_inicio * 80);
stepper.setCurrentPosition(0);
//Serial.println("Seteado a 0");
delay(V_retardo);
//Serial.println("iniciamos despues del delay el travelling");
stepper.runToNewPosition(V_pasos);
}


// |- - - - - - - - - - - - |
// |                        |
// |   ** Bloque inicio **  |
// |                        |
// |- - - - - - - - - - - - |

//Movemos el motor hasta el punto de inicio para ajustar el plano si es necesario

void Inicio(YunClient client){
  
  stepper.setMaxSpeed(2000);
  stepper.setAcceleration(200);
  
  while (stepper.currentPosition() < T_inicio * 80)
  {
    stepper.runToNewPosition(T_inicio * 80 - T_final * 80);
    stepper.run();
  }
  stepper.setCurrentPosition(0);
}

// |- - - - - - - - - - - - |
// |                        |
// |   ** Bloque final **   |
// |                        |
// |- - - - - - - - - - - - |

//Movemos el motor hasta el punto final para ajustar el plano si es necesario

void Final(YunClient client){
  
  stepper.setMaxSpeed(2000);
  stepper.setAcceleration(200);
  
  while (stepper.currentPosition() < T_final * 80)
  {
    stepper.runToNewPosition(T_final * 80);
    stepper.run();
  }
  stepper.setCurrentPosition(T_final * 80);
}

// |- - - - - - - - - - - - - - -|
// |                             |
// |  ** Inicio de Timelapse **  |
// |                             |
// |- - - - - - - - - - - - - - -|

//Bloque llamado al inicial el timelapse, donde haremos todos los cálculos y enviaremos los movimientos.
//Al iniciar enviamos la config actual por el serial.

void Tstart(YunClient client){  
  String frase1 = "Timelapse Iniciando a ";
  String frase2 = frase1 + T_inicio;
  String frase3 = frase2 + " mm de inicio, hasta " + T_final;
  String frase4 = frase3 + " mm del final, disparando " + T_fotos;
  String frase5 = frase4 + " fotos con un intervalo de  " + T_intervalo;
Serial.println(frase5 + " Segundos");

stepper.setMaxSpeed(T_velocidad);
stepper.setAcceleration(T_aceleracion);

unsigned long T_pasos = (T_final - T_inicio) * 80;
unsigned long T_mover = T_pasos / T_fotos;
  
stepper.runToNewPosition(T_inicio * 80);
stepper.setCurrentPosition(0);
  
delay(T_retardo);
  
for (unsigned long Tvar = 0; Tvar <= T_pasos; Tvar= Tvar + T_mover){  
    stepper.runToNewPosition(Tvar);
    delay(T_intervalo /2);
    digitalWrite(3,HIGH);
    delay(200);
    digitalWrite(3,LOW);
    delay(T_intervalo / 2);
    Serial.println(Tvar);
      }
}

// |- - - - - - - - - - - - - -|
// |                           |
// |  ** Homming al inicio **  |
// |                           |
// |- - - - - - - - - - - - - -|

//Bloque llamado al iniciar el sketch.
//LLeva el motor hasta el endstop inicial y setea la posición a 0.

void Pinicio(){

  stepper.setMaxSpeed(1200);
  stepper.setCurrentPosition(10);
  stepper.setAcceleration(1200);
  
  hBval = digitalRead(homeButton);
  while (hBval == HIGH)
  {
    stepper.moveTo(-99999);
    stepper.run();
    hBval = digitalRead(homeButton);
  }
  stepper.setCurrentPosition(0);
}

// |- - - - - - - - - - - - - - - - -|
// |                                 |
// |  ** Homming desde interface **  |
// |                                 |
// |- - - - - - - - - - - - - - - - -|

//Bloque para homming desde la web.
//LLeva el motor hasta el endstop inicial y setea la posición a 0.

void Home(YunClient client){

  stepper.setMaxSpeed(1200);
  stepper.setCurrentPosition(10);
  stepper.setAcceleration(1200);
  
  hBval = digitalRead(homeButton);
  while (hBval == HIGH)
  {
    stepper.moveTo(-99999);
    stepper.run();
    hBval = digitalRead(homeButton);
  }
  stepper.setCurrentPosition(0);
}

Salu2!
Citar
#16
Me parece interesantísimo este proyecto!
Voy pillando sitio en el hilo para estar al tanto en los avances jeje.
No tengo mucha idea de programación por lo que no creo que os pueda echar una mano pero si me encanta construir cosas así que si necesitáis un tester (y no tengo que hacer demasiado desembolso) contad conmigo.
Saludos!


Sent from my iPhone using Tapatalk
Citar
#17
Lo del motor brushless lo pensé en un inicio, pero para timelapse me parecía que no se podría hacer de manera correcta, si elcable no esta recto o cuando el cable cam este en una punta, ttendría pendiente y si dejas de alimentar el brushless caería todo el carro por su peso, con un motor pad al mantener la tensión del paso queda clavado sin moverse independientemente de la inclinación del cable. Por cierto existe un nema17 en versión corta y por tanto pesa algo menos, de coste es igual, quizás ese sería mejor que el tradicional.

El código que pasas es para timelapse, tendríamos que poner también el código para el contro manual, con control de marcha al ante, atrás y aceleración. Y también el control del servo para el giro, en timelapse programado y en manual giro en un sentido y en otro.

También comentas lo de tiempo de exposición y foto..... desde el yun ???
se puede desde el yun activar el disparo de la gopro y tiempo de exposición?
Y si fuera otro tipo de cámara de acción?
No se, a mi lo de programar el timelapse en cuento al movimiento del carro perfecto ( distancia total y tiempo entre punto de partida y llegada) pero el control de la cámara lo dejaría aparte, ya que la mayoría de ellas tienen sus propias opciones para ello. Yo tengo la YI que es un pepino por 65€ que me costo y el modo timelapse tiene varias opciones muy chulas.
No se que opináis?
Citar
#18
De todas maneras que Bruselas propones?
Y con las características y viendo el peso del que ya tengo, puedo diseñar un cuerpo de motor y desarrollos para el.
Citar
#19
El código está preparado para timelapse, y para videos en travelling. Tu le das punto de inicio, punto final, velocidad, aceleración y un retardo si quieres, y al darle al start hace el travelling directo.

Después habría que implementar el control manual, pero el automático está para vídeo y para timelapse.

El del servo en cuanto tenga montado el bicho y lo pueda probar, es muy sencillo tb de realizar.

Sobre el control de la cámara, lo que debemos de controlar es el disparo. Se pueden controlar otros parámetros, pero como dices ya mejor desde la cámara. Pero el disparo si que debemos controlarlo para que vaya sincronizado el movimiento con los disparos, y no dispare cuando está en movimiento ya que jode completamente el timelapse.

Con las cámaras reflex es un minijack y llevar un pin a masa, y con la gopro se le da por wifi.

Lo del tiempo de exposición es para los que quieran usar reflex, ya que es símplemente lo que dura el impulso en el pin del minjack Guiño

El nema que tengo es de perfil bajo, unos 34mm. Los normales deberían de pesar bastante mal

Sobre lo de brushless, en teoría estas cuerdas deberían de ir tensas, no? las que vi tenían incluso un tensor tipo eslinga en un extremo. Tenía en mente que era siempre sobre cable tenso Guiño

Ya está la máquina de producir escupiendo piezas! jajajajaja

resim
Citar
#20
Pla o abs?
Si es ABS muy bien resultado, con estas piezas grandes el Watling es.un fastidio.
como te digo lo del disparo genial si es para una gopro,pero si es para su o yo o la que sea, por wifi no se puede, al menos la yi, si no es con su app no hay manera de entrar en ella. Pero me imagino que podrá ser una opción a quitar o poner a gusto de cada uno.
Citar