Mostrando entradas con la etiqueta Nema-17 L298N. Mostrar todas las entradas
Mostrando entradas con la etiqueta Nema-17 L298N. Mostrar todas las entradas

domingo, 20 de abril de 2014

Robot panorámico XS (la electrónica)

Por si alguién quiere montarse uno, os dejo un poco de información referente al conexionado de los diferentes elementos. En alguna otra ocasión ya sugerí que es recomendable tener ciertos conocimientos básicos de electrónica y programación del Arduino, más que nada que en google se puede encontrar información pero cuando surgen problemas especificos es cuando uno tiene que auto-espavilarse como pueda. Yo siempre he intentado ayudar, pero no dispongo de todo el tiempo del mundo  para hacerlo.

En mi caso utilizo una pantalla LCD de 4 lineas x 20 caracteres y un joystick sacado de un nunchuck de la wii , como que estos dos componentes son un poco usuales , os voy a describir a continuación como hacer funcionar el robot con una shield de pantalla LCD de 2x16 caracteres con pulsadores como la de la siguinete captura:

Usando una shield como esta reduciremos cableado y posibles errores de conexionado. Como pega, no es lo mismo tener una pantalla de 32 (2x16) caracteres que una de 80 (4x20) y eso se ve reflejado a la hora de darle un aspecto más bonito a la aplicación o un muestreo extra de información que siempre es mejor.

Y obviamente si vamos a utilizar esta pantalla habrá que usar un programa en concreto, mientras que en la de 4x20 caracteres hay que "reformarlo" en gran parte, debido entre otras cosas que se comunica sólo mediante 4 cables mediante el bus I2C (positivo, negativo, SDA y SCL) y que al no tener pulsadores incorporados hay que cablearlo aparte definiendo nuevas entradas.


Una de las ventajas del LCD shield es que incorpora de serie varios botones (UP, DOWN, LEFT, RIGHT y SELECT) , todos ellos van dirigidos hacia la entrada análogica 0 de nuestro Arduino. Por cierto alguien se preguntará porque un MEGA y no un UNO. El problema es que el UNO tiene una capacidad de memoria de 32 kB y el programa que vamos a utilizar ronda los 31 kB. Otro de los problemas es que al utilizar la shield LCD y "montarla" justo encima hay que empezar a hacer "guarrerias" para conectar los cables que van hacia los drivers de potencia etc...

A lo que iva...todo y vivir en un mundo digital lleno de ceros y unos, es muy bonito usar las entradas analógicas que nos brinda el Arduino. Mediante un voltage de referencia de +5v que podemos aplicar a dichas entradas podemos tratarlas luego internamente de varias maneras generando una entrada multiplexada y ahorrandonos entradas.

Si le aplicamos a una entrada análogica 0 v obtendremos un valor de gestión de valor 0, mientras que si aplicamos 5v en la entrada obtendremos un valor de gestión de 1023. Es decir tenemos una resolución de 1024 con el que podemos jugar...Ahora bién, y electricamente como podemos aplicar un valor variable mediante pulsadores? Muy fácil ! con el uso de resistencias tal y como se muestra en el siguiente esquema:


Estas resistencias ya están montadas en nuestra shield, por lo que no deberemos preocuparnos. Por ejemplo si pulsaramos sobre el pulsador RIGHT provovariamos que en la entrada AD0 un voltaje de 0v, mientras que si pulsaramos sobre UP deberiamos calcular el divisor de tensión generado por las resistencias R2 y R3. A efectos practicos no nos interesa en concreto el valor recibido a la entrada AD0, pues nosotros vamos a tratar con el valor de gestión que reciba nuestro Arduino. Y que valor es este? Os propongo que utiliceis el siguiente sketch para ver como se comportan los pulsadores en vuestro caso:

/*
Test LCD shield
by XavierGP
*/

#include <LiquidCrystal.h>           // incluimos la LiquidCrystal LCD library
int valor;                           // variable recibida en el keypad
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // define los pins del LCD

void setup() { 
lcd.begin(16, 2);
lcd.print(" Hola XavierGP !");
delay(2500);
}

void loop(){
valor=analogRead(0);
if(valor<1020){
lcd.clear();
lcd.print(valor);
delay(350);       
}
}

Una vez cargado este sketch y con la shield LCD montada encima el Arduino observaremos como cambian los valores dependiendo del pulsador que estamos apretando. Estos valores nos serán necesarios a la hora de realizar ajustes en nuestro programa. No todas las shields proporcionan el mismo valor por lo que quizás sea necesario corregirlos. Os enseño unas muestras entre dos shields en principio iguales pero a la realidad los valores cambian:


Finalmente os adjunto el circuito eléctrico básico para que funcione el robot:



Empezando por la parte inferior izquierda encontramos una batería típica de 12v / 7Ah. de la cual salen dos pares de cables, unos de ellos se van directamente hacia la alimentación del Arduino (hay que comprar el jack adecuado! En el centro de este soldaremos el positivo mientras que el negativo va en el lado exterior del mismo). El propio arduino dispone de un regulador/estabilizador incorporado pero no estaria de más ponerle algun tipo de proteción intermedia...

El otro par de cables van hacia un step-down (regulador de voltage) en el que obtengo una tensión de salida constante de 5v y hasta 10Amperios de intensidad entre el cable amarillo y cualquiera de los negros. Estos 5v los utilizaremos para alimentar los motores(al menos con los motores que yo utilizo!, si montais otros motores quizas haya que cambiar el step down por un regulador de voltage) que seran gestionados por los drivers L298N. El driver se comportará como un amplificador de potencia ya que la intensidad que nos ofrece el arduino en sus salidas es muy pequeña para alimentar a los motores.

Luego tenemos dos grupos de 4 cables que van de las sálidas 36, 38, 40 y 42 , y 46, 48, 50 y 52 que van hacia las entradas de pilotaje de los drivers IN1, IN2, IN3 e IN4 . Cada grupo de 4 conductores van hacia cada uno de los dos drivers.  Es recomendable seguir bién el orden. Podeis leer posts antiguos sobre motores paso a paso para entender como funcionan estos...

A las 4 salidas del driver conectaremos nuestros motores paso a paso.

Luego nos toca conectar el relé en la sálida 25 de nuestro arduino , y el otro borne del relé a GND. En este esquema no está marcado correctamente para no liar más entre los diferentes conductores, pero debajo de los PINS 52 y 53 tenemos dos pins de GND. Y para vuestra información encima de los PINS22 y 23 tenemos dos pins que nos ofrecen 5v continuadamante.

Un detalle "tonto" pero necesario es la colocación de un diodo en paralelo a la bobina del relé para eliminar la corriente generada al desactivar el relé, protegiendonos nuestra salida del arduino.

Este relé es el encargado de activar el contacto remoto de nuestra camara.

Finalmente y como "accesorios" extras tengo montado unos sensores de temperatura tipo LM35 que a su vez gestionan el funcionamiento de otro relé que activa/desactiva el ventilador de refrigeración del sistema. En este caso la lectura la realizo en la entrada análogica A6 y la salida va al PIN 24. Sólo como curiosidad , en mi robot XS con pantalla más grande gestiono las temperaturas de los dos drivers por lo que utilizo dos LM35 , uno va a la entrada A6 y el otro a la A7, pero sigue existiendo sólo un ventilador que enfria a los dos.

Os dejo un ejemplo del conexionado del mismo, con la diferencia que aqui está conectado en el borne A5 en vez del A6. Podeis encontrar infinidad de información en Google sobre circuitos con el LM35.



Y otra "mariconada" más es un divisor de tensión que sirve para informarme del voltage de la bateria. Esta información es ofrecida cuando el robot retorna a la posición de inicio de cada linea, pero a efectos prácticos si no lo tenemos habilitado el programa en si cumple con su proposito. Esto lo gestiono a través de la entrada análogica A5, siguiendo el siguiente principio de circuito:


Finalmente os adjunto una vista de como lo tengo yo montado , pero cuidadín , repito, yo no utilizo la SHIELD LCD !


Si lo conectáis todo igual , y utilizais los mismos motores (ver post de lista de la compra de materiales) , tan sólo faltará casi cargar el programa, pero esto será para otro dia.

Saludos y DIY! 

sábado, 1 de febrero de 2014

Pruebas con motores paso a paso (II)

Seguimos batallando con el arduino y los motores paso a paso.

Tal y como vemos en la siguiente imagen aparece una estrella de los vientos junto a 4 bobinas. De todos es sabido y experimentado en nuestra infancia el efecto electroimán : cuando hacemos pasar una corriente por un bobinado (en nuestro caso el estator del motor) se ejerce un campo magnético y este es capaz de hacer mover elementos conductores (en nuestro caso el rotor del motor).

Logicamente si queremos que este movimiento se convierta en circular , necesitaremos como mínimo dos bobinados y eso es lo que realmente tenemos en nuestros motores paso a paso.

En la siguiente imagen nos aparecen 4 bobinados y creo que es una de las maneras fácil de entender un poco como funciona.

En la realidad los bobinados A y C están unidos al igual que B y D. Y también en un motor de 200 pasos deberia haber un total de 200 bobinas unidas en dos grupos de 100 + 100 distribuidas alternativamente .

Tal y como dijimos el Arduino envia una serie de impulsos hacia el driver. Y este driver es el que convierte los impulsos en "potencia".

En principio la libreria Stepper de arduino convierte nuestra instrucción de movimiento del motor en impulsos. Es decir cuando nosotros escribimos myStepper.step(numero_de_impulsos); lo que en realidad le estamos diciendo es que realice el numero_de_impulsos y los distribuye en 4 movimientos o ciclos repetitivos y luego activando las salidas correspondientes.

Imaginemos que decimos myStepper.step(1); al tratarse del primer movimiento se genera un pulso y empieza a contar desde la tabla la primera columna, es decir estamos en el movimiento 1. Se activan las bobinas A (roja) y la Bobina C(verde). Nuestro rotor se debería posicionar entre A y C es decir rumbo Norte.

Si a continuación escribo myStepper.step(2); generaria dos impulsos por lo que se me ejecutaria el movimiento 2 y luego el 3 (nuestro arduino sabe en que posición de movimiento se quedó la última vez) . Primero activariamos las bobinas C y B y a continuación la B y D. (giro hacia el Este y luego hacia el Sur)

Si acto seguido ejecutamos la instrucción myStepper.step(3); quiere decir que queremos dar 3 impulsos más . Ahora aqui el "arduino" sabe en que punto estamos de nuestro orden y ejecutará el movimiento 4 y luego saltará al 1 y al 2, pues se repiten los ordenes ciclícamente. (movimiento hacia el oeste, norte y este)

Si todo esto lo traspasamos a los 200 "bobinados" obtenemos un movimiento bastante controlado.

Si queremos mover en el otro sentido, sólo hay que interponer el signo negativo antes del número de pulsos y lo que hará el arduino invertir el orden de pulsos . Imaginamos que estamos en el movimiento 3, pues saltaria al movimiento 2 y luego al 1. La instrucción seria myStepper.step(-200); para dar una vuelta entera.

Ahora que sabemos un poco más de como se mueven los motores es hora de testear si estos pulsos de nuestro arduino se "pierden" por el camino y no llegan a las bobinas de nuestro motor.

Para ello nos fijaremos en el siguiente esquema:


Una vez tengamos cableado igual nuestro circuito, cargaremos en nuestro arduino el siguiente sketch:

#include <Stepper.h>           // incluimos la Stepper library
#define motorStepsX 200     // Pasos motor  360º/1.8º
Stepper myStepperX(motorStepsX, 8, 9, 10, 11); 
void setup() {
myStepperX.setSpeed(20);  
}
void loop(){
myStepperX.step(1); 
delay(30000);
}

Este sketch va generando impulsos hacia el motor cada 30 segundos , por lo que deberemos ir a la idea, pues continuamente irá cambiando del movimiento 1 , al 2, luego 3, i finalmente el 4. Seguidamente volverá a iniciar el ciclo y asi sucesivamente. Por cierto a mi haciendo todas las pruebas siempre me ha arrancado con el movimiento 2.

Cojeremos nuestro múltimetro y lo pondremos para medir tensión VDC. El borne negativo del tester lo colocaremos al GND del arduino durante todo momento.

Mediante el otro terminal del multimetro podemos probar si se cumple el orden de la tabla anterior (es posible que cuando empecemos con nuestras mediciones ya estemos en el paso 1)

Pondremos la punta del tester en el PIN8 del arduino i verificaremos que hay 5 voltios. Luego  verificaremos que exista también en IN1 del driver (5v),  i finalmente en OUT 1 deberia existir aproximadamente la mitad de voltaje aplicado a VCC (alimentación del motor, imaginemos que lo alimentamos a 12v) al que deberiamos restar la caida de tensión de los diodos (puede ser hasta 0,7v), por lo que deberiamos encontrar como máximo 6V, pero tranquilamente podrian ser 5.3 voltios. Si miramos en OUT2 deberiamos encontrar la misma tensión pero en negativo, es decir entre -6v i -5.3v . Luego la tensión entre OUT1 y OUT2 será VCC menos dos caidas de tensión del diodo.

Si estuvieramos en el movimiento 1 nos pasaria lo mismo en el PIN10 (5v) , IN3(5v) i en OUT3 (6v / 5.3v) , mientras que en OUT4 (-5.3v / -6v) 

El resto de PINs (9 y 11) , IN2 e IN4 deberian marcar 0 v.

Todo esto con suficiente nervio pues en 30 segundos cambia al siguinete movimiento:

En el movimiento 2, que deberiamos tener lo siguiente:
PIN9 y PIN10 = 5v
PIN8 y PIN11 = 0v
IN2 y IN3 = 5v
IN1 y IN4 = 0v
OUT 2 y OUT 3 = Vcc-diodo (5.3-6v)
OUT 1 y OUT 4 = -Vcc+diodo (-5.3 -6v)

En el movimiento 3, que deberiamos tener lo siguiente:
PIN9 y PIN11 = 5v
PIN8 y PIN10 = 0v
IN2 y IN4 = 5v
IN1 y IN3 = 0v
OUT 2 y OUT 4 = Vcc-diodo (5.3-6v)
OUT 1 y OUT 3 = -Vcc+diodo (-5.3 -6v)

En el movimiento 4, que deberiamos tener lo siguiente:
PIN8 y PIN11 = 5v
PIN9 y PIN10 = 0v
IN1 y IN4 = 5v
IN2 y IN3 = 0v
OUT 1 y OUT 4 = Vcc-diodo (5.3-6v)
OUT 2 y OUT 3 = -Vcc+diodo (-5.3 -6v)

Os dejo un video a ver si se entiende mejor...




Si todo la secuencia es correcta, el motor deberia funcionar siempre y cuando la tensión de alimentación VCC  y la posible potencia demandada a nuestra fuente de alimentación sea suficiente.

Si la secuencia no es correcta hay que verificar las señales entre Arduino y el driver que posiblemente esten mal, o bién el driver está en mal estado.

Finalmente me gustaria comentar que modificando ligeramente la libreria Stepper podemos conseguir más resolución en nuestros motores, consiguiendo por ejemplo medios pasos con lo que luego nuestro motor deberia dar 400 pasos para generar una vuelta entera, y seria capaz de parar en sitios intermedios (NE, SE, SO, y NO) pero en su contra perderiamos torque .

Si alguien le interesa la libreria modificada para medios pasos me la puede pedir.

También comentar que hay la opción de hacer 1/4 de paso, 1/8 y hasta 1/16 de paso , estos son llamados micropasos. Si quisieramos utilizar estas resoluciones en este tipo de driver deberiamos usar salidas PWM en nuestro arduino y la libreria se empieza a complicar y por mi experiencia es que con el Arduino le falta "velocidad" de procesador para lograr un  movimiento suave y uniforme. Hay otros drivers que ya vienen preparados y con unos simples puentes  se puede cambiar la resolución. 


viernes, 4 de noviembre de 2011

Robot panoramico...vamos prosperando

    Una vez montada la shield de potencia de los motores y tras familiarizarme con el lenguaje Arduino, me faltaba unos pulsadores para mover el motor manualmente, pues la intención era que se pudiera definir el angulo de la panoramica sin tener de entrar en programación, para evitar de pasear el portatil junto la camara mas otros "trastos" para realizar una panoramica. No tenia muy claro si utilizar un mando remoto inhalambrico o bién con pulsadores, finalmente me decanté por lo tradicional:
En la misma placa donde hay los pulsadores en cruz , he dispuesto de dos botones más que sirven para validar los extremos opuestos de la captura, luego el programa se autoajusta al número de filas y columnas necesarios
Ahora tocaba programar para "probar" si realmente me podia salir con la mia, y aquí está (cuidadín falta depurarlo y corregir errores, pero funciona):

/*
 Photo Robot 2x L298N + Nema 17
 language: Wiring/Arduino

 This program drives two bipolar stepper motor.
 The motor is attached to digital pins 8+9 & 10+12 of the Arduino.
 The pthoto-shots signals it's actuated by relay -Pin 13-
 Movement manual motor by array switchs

 Created 26 Oct. 2011

 by XavierGP

 */

// define the pins used


#include <Stepper.h>        // incluimos la Stepper library

#define motorStepsX 200     // Pasos motor X 360º/1.8º
#define motorStepsY 200     // Pasos motor Y 360º/1.8º                     
#define motorPinX1 10       // Pin OUT 1 control motor X
#define motorPinX2 12       // Pin OUT 2 control motor X
#define enablePin 11        // Pin OUT 11 habilita tensión en motores
#define motorPinY1 8        // Pin OUT 1 control motor Y
#define motorPinY2 9        // Pin OUT 2 control motor Y


int pasoX=10;                // º entre capturas eje X DÓNDE 10 SON 18º
int pasoY=10;                // º entre capturas eje Y
int xact=0;                 // º actual eje X
int yact=0;                 // º actual eje Y
int xmax=0;                 // º posición máxima eje X
int xmin=0;                 // º posición mínima eje X
int ymax=0;                 // º posición máxima eje Y
int ymin=0;                 // º posición mínima eje Y
int xtemp=0;
int ytemp=0;
int definecornerA=0;
int definecornerB=0;
int nshot=0;
int filasX;                 // número de filas eje X >> (xmax-xmin)/pasoX
int filasXX=0;
int columnasY;              // número de columnas eje Y    >> (ymax-ymin)/pasoY
int columnasYY=0;
int previsionShot;          // prevision número shots   filasX * columnasY

// initialize of the Stepper library:
Stepper myStepperX(motorStepsX, motorPinX1,motorPinX2); // libreria motor X
Stepper myStepperY(motorStepsY, motorPinY1,motorPinY2); // libreria motor Y

void setup() {

 pinMode(2, INPUT);        // Input digital 2 =  confirmación corner A 
 pinMode(3, INPUT);        // Input digital 3 =  confirmación corner B
 pinMode(4, INPUT);        // Input digital 4 =  -Y
 pinMode(5, INPUT);        // Input digital 5 =  +Y
 pinMode(6, INPUT);        // Input digital 6 =  +X
 pinMode(7, INPUT);        // Input digital 7 =  -X
 pinMode(13, OUTPUT);      // Output digital 13 = shot
 myStepperX.setSpeed(30); // set the motor X speed at 100 RPMS:
 myStepperY.setSpeed(30); // set the motor Y speed at 100 RPMS:
 
 pinMode(enablePin, OUTPUT);
 digitalWrite(enablePin, HIGH);  // habilita tensión en motores

 Serial.begin(9600);           // Initialize the Serial port:
 Serial.println("Posicione mediante cursores el extremo de origen y valide con CORNER A. Este pasara a ser el punto 0,0");
 Serial.println("A continuacion posicione mediante el otro extremo y valide con CORNER B");
}

void loop(){

  if(definecornerA==0 || definecornerB==0)   //  definimos máximos y mínimos de X e Y
 {
  int sensorValue0 = digitalRead(6);   // Input digital 2 =  +X
  int sensorValue1 = digitalRead(7);   // Input digital 3 =  -X
  int sensorValue2 = digitalRead(5);   // Input digital 4 =  -Y
  int sensorValue3 = digitalRead(4);   // Input digital 5 =  +Y
  int sensorValue4 = digitalRead(2);   // Input digital 6 =  confirmación corner A
  int sensorValue5 = digitalRead(3);   // Input digital 7 =  confirmación corner B
   
  if(sensorValue0==HIGH)
  {
    xact=xact+pasoX;
    Serial.print(xact*1.8);
    Serial.print("  ,  ");
    Serial.println(yact*1.8);
  }
 
   if(sensorValue1==HIGH)
  {
    xact=xact-pasoX;
    Serial.print(xact*1.8);
    Serial.print("  ,  "); 
    Serial.println(yact*1.8);
  }
   if(sensorValue3==HIGH)
  {
    yact=yact-pasoY;
    Serial.print(xact*1.8);
    Serial.print("  ,  ");
    Serial.println(yact*1.8);
  }
   if(sensorValue2==HIGH)
  {
    yact=yact+pasoY;
    Serial.print(xact*1.8);
    Serial.print("  ,  ");
    Serial.println(yact*1.8);
  }
   if(definecornerA!=1){
   if(sensorValue4==HIGH)
  {
    xmin=xact;
    ymin=yact;
    definecornerA=1;
    Serial.println("Esquina A -inferior izquierda- CONFIRMADA ! Punto de inicio");
  }
   }
   if(definecornerB!=1 && definecornerA==1){
   if(sensorValue5==HIGH)
  {
    xmax=xact;
    ymax=yact;
    definecornerB=1;
    Serial.println("Esquina B -superior derecha- CONFIRMADA !");
  }
   }
  myStepperX.step(xact-xtemp);
  xtemp=xact;
  myStepperY.step(yact-ytemp);
  ytemp=yact;
  delay(200);
 }
 else{

  xact=-xmin;
  yact=-ymin;
  filasX=((xmax-xmin)/pasoX)+1;
  filasXX=filasX;
  columnasY=((ymax-ymin)/pasoY)+1;
  columnasYY=columnasY;
  previsionShot=filasX*columnasY;
  myStepperX.step(-(filasX-1)*pasoX);
  myStepperY.step(-(columnasY-1)*pasoY);   
  Serial.println("Panorama data:");
  Serial.println("n SHOT :  Filas X , Columna Y , grados X, grados Y");
  Serial.print(previsionShot);
  Serial.print("      ,    ");
  Serial.print(filasX);
  Serial.print("     ,   ");
  Serial.print(columnasY);
  Serial.print("     ,   ");
  Serial.print((-xmin+xmax)*1.8);
  Serial.print("  ,   ");
  Serial.println((-ymin+ymax)*1.8);
  Serial.println("Home position! Pulse Corner A  para empezar");
 
  int sensorValue4 = digitalRead(2);   // Input digital 9 =  confirmación corner A
  while(digitalRead(2)==LOW)
  {
    }
  Serial.println("Start!");
  Serial.println("SHOT numero:  Filas X , Columna Y ,posicion X, posición Y");
 
xmax=xmax-xmin;
ymax=ymax-ymin;
xmin=0;
ymin=0;
xact=0;
yact=0;
 
  for(int i=0; i<(columnasY); (i++))        
  {
   delay(1000);
    for(int j=0; j<filasX; (j++))
   {
     digitalWrite(13, HIGH);
     delay(500);
     digitalWrite(13, LOW);
     nshot=nshot++;
   
   Serial.print(nshot);
   Serial.print("   :   ");
   Serial.print(j+1);
   Serial.print("   ,   ");
   Serial.print(i+1);
   Serial.print("   ,   ");
   Serial.print(xact*1.8);
   Serial.print("   ,   ");
   Serial.println(yact*1.8);
   
     delay(1500);
    
     if(j!=(filasX+1)){  ///   if(j!=(filasX-1*sentidoX)-1)
     myStepperX.step(pasoX);
     xact=xact+(pasoX);
     } 
     delay(1500);
    }
  
   myStepperX.step((-filasXX)*pasoX);
   xact=0;
   if(i!=columnasY-1){         
   myStepperY.step(pasoY);
   }                                
   yact=yact+(pasoY);
   delay(1000);
    }
    Serial.println("Panoramica completa!");
  myStepperY.step((-columnasYY+1)*pasoY);
  delay(1000000);
 }
}


Los que dominais la programación posiblemente lo reduciriais a la mitad....pero eso es cuestion de minimizarlo (ya se hará!)


Tuve varios problemas (dependiendo de si la panoramica iba de izquierda a derechas o al revés) provocandome duros "quebraderos de cabeza" con los signos < > por lo que al final decidí que sólo seria viable en sentido horario al igual que se mueve el sol (de izquierda a derecha y de abajo a arriba).


Luego me di cuenta que los L298N se calentaban un huevo (si , casi para poder hacer huevos fritos) por lo que temporalmente le monté un radiador casero con una platina de aluminio. Ahora tengo pendiente montarle un ventilador forzado. Aparte del factor temperatura me di cuenta porque cada vez tenia que incrementar más el voltaje de los motores Nema 17 (incluso alimentandolos a 6 voltios cuando lo necesario son 2.8 v 2A).

De momento parece que tiene la intención de funcionar, todo y desconocer si los motores seran capaces de mover los 3 kg....

Os dejo un par de capturas de pantalla de como se ve desde el PC:
Y finalmente unos videos en funcionamiento (mañana intentaré grabar uno mejor):



Ahora tocará la parte que para mi es más complicada: la mecánica por lo que tengo previsto tomarmela con muucha calma, pero sin pausa . A cacharrear  !!!