Carril macro con arduino IV

Estoy desarrollando las modificaciones al stacking rail que comentaba hace unos dias.
Descargue la sdk de canon y estoy siguiendo este tutorial para implementarlo. La idea es crear un programa en C# (Visual Studio 2012) que use el SDK de Canon y la libreria de vision artificial OpenCV  (aqui como implementar a VS2012)  para el control de la camara y el carril. en el futuro el carril tendra varios ejes en la bandeja de la muestra, he visto que se tarda mucho tiempo en preparar la posicion de algo tan pequeño. Tambien quiero incluir la iluminacion al aparato, pero no tengo mas pines libres, dejo solo el encendido y apagado de la iluminacion a 12V. De esto y de mover el carril se encargara arduino, enviando y recibiendo datos del y al programa.
La idea es ver a pantalla completa la imagen de la camara en LiveMode y los controles de pc, camara y carril a modo de marco o lateral o algo asi, teniendo asi todos los controles del proceso a mano.
Pense que disponia de una camara canon DLSR modelo 400D ( mi primera reflex ) para pruebas, pero despues de mucho sin uso esta muerta .. asi que para las pruebas uso la camara con la que trabajo ... mi amada canon 7D, mientras sea asi no voy a enredar mucho con la sdk y me voy a limitar a modificar el programa de ejemplo del tutorial que sigo, dejo un screensave de lo que llevo, poco mas que maximizar y eliminar los marcos, botones y demas, me faltan los controles de los 3 ejes de la muestra.

Creo que lo mas rapido es hacer un shield para arduino en vez de desarrollar una placa completa, la razon, no quiero soldar SMD, no se y tardaria, y el chip conversor FTDI lo es, usare alguno de los arduino originales que tengo por casa.
El shield controla 4 motores paso a paso bipolares (ULN2004), uno mueve la camara y los otros tres mueven la muestra en 3 ejes. Un 2n222 enciende o apaga la iluminacion y dos finales de carril limitan el movimiento del eje de la camara.

Dejo los archivos en Eagle del shield, aqui el brd y aqui el sch, aqui el pdf en A4.
Aqui el codigo arduino y aqui el codigo C# para VisualStudio2012. ( en cuanto los termine los subo )

Laser trigger con arduino

Me surgio la necesidad de una barrera que disparara la camara para tomar unas fotos. Las fotos aun no estan hechas, pero la barrera si.

Dejo codigo y pcb

NOTA: para la realizacion de este proyecto estoy usando unas muestras de ATMEL. En particular el ATME328-pu. Al programarlo me dice que no reconoce el chip y da error. Hay un archivo llamado `avrdude.conf` en uno de los subdirectorios del directorio arduino, la solucion es buscar la linea  " signature       = 0x1e 0x95 0x0F; " car y cambiar el 0F por 14, salvar y reiniciar arduino.

Esta seria la segunda version, hace unos dias
Aqui la calculadora de resistencias  para el LM317 que uso para los 3v del laser.

Carril macro con arduino III

De compra semanal me he cruzado con un controlador clonico de ps2 y creo que sera mejor para el control del carril pero al tenerlo en la mano me he dado cuenta de las posibilidades, por esto creo que finalizare la version 1 del carril cuando implemente las siguientes mejoras.

• encendido de la iluminacion por mando 
• posicionado por mando de la camara, y los otros 3 ejes para la muestra  ( arriba / abajo, izquierda/derecha, delante/detras y giro horizontal)

Al tener el mando he visto que seria genial poder controlar la camara totalmente y visualizar los datos del carril junto a la imagen tomada en liveview, y los parametros de la camara en la misma pantalla y todo controlado por el mando de playstation que al terminar me lo mande al helicon focus, ouh yeah! me ahorraria mucho tiempo en el preparado de cada foto, facilitandome tomar fotos que de otra manera no podria, asi que creo mudare el cerebro a un programa en C# para windows y dejare el arduino para el control de motores sensores y demas. Aqui mas info.


El cableado seria el siguiente:

La libreria aqui
Mas informacion aqui

y mas tomas con el hardware y software actuales:

Carril macro con arduino II

Ya implemente el disparador IR al rail y al codigo del arduino, asi que puedo disparar muchas camaras canon en este carril, sin necesidad del cable, de momento probado en los modelos 400D y 7D.
El unico problema con el disparador IR seria en camaras sin modo liveview, lo normal en macrofotografia es bloquear el espejo antes de disparar para evitar esa vibracion al disparar, el disparo con IR no permite usar esta funcion de la camara, pero usandola en modo livewiev ya la activamos a la par que vemos lo que disparamos.

Empezando a disparar con el rail me he dado cuenta de algunos aspectos del diseño que son mejorables. Finalmente voy a poner un par de encoder opticos para poder posicionar el carril donde quiera, no conte al diseñar los largos diferentes de cada lente, extension, etc.
Tambien quiero incluir una extension a la pcb para poder mover 3 motores paso a paso mas para posicionar en los tres ejes la muestra, tambien quiero poder controlar por MOSFET desde arduino el encendido de la iluminacion.

Haciendo las primeras pruebas me he dado cuenta que es un poco incomodo estar doblado colocando la muestra, posicionando el carril, etc. Asi que al rato me acerco por un mando de playstation y se lo implemento al cacharro. Creo que voy a eliminar el potenciometro y el boton que ahora uso de entrada de datos y dejar solo el control.

link con informacion

Primeras fotos, realizadas a f4 en la lente principal (90mm 1:1 tamron dimacro) y f1.8 invertida la segunda lente, un 50mm canon, en una 7D en modo liveview y silent mode1 para evitar vibracion en lo posible.

pila montada en photoshop

pila montana en zerene stacker

pila montada con helicon focus

Como se ve me falta mucho por aprender aun, pero el rail consigue una calidad mas que aceptable. En proximas pruebas voy a usar helicon focus, es muy rapido y facil de usar.

Carril macro con arduino

Hola

Quiero tambien compartir un stacking rail con arduino tambien, en principio para camaras canon.

Tanto el codigo como los archivos eagle iran cambiando segun avance el proyecto, aunque funcional solo es un prototipo de prueba. Por ejemplo estan son las mejoras que tengo pendientesy alguna otra que ahora se me va.

• disparador IR en vez de por cable, seria para todas las camaras canon y nos ahorramos el opto disparador.
• dos encoder, uno para apuntamiento manual mecanico, y el otro para sensar la posicion de la camara, no se si son caros, pero tengo muchos de despiece de impresoras.
• un mosfet que controle la iluminacion DC.

La presencia visual es horrible lo se, pero es una maquina mucho mas precisa de lo que pense en un principio, cuando termine la CNC hare la version `final`.

Los archivos en eagle .brd .sch .pdf 

y el codigo en arduino 

Helicoptero y l298

Hola a todos.

Por otros proyectos tengo detenido el quadcopter, pero tengo un helicoptero con motores DC de escobillas de aproximadamente medio metro de largo que va a suplir su carencia. El receptor y el mando con el emisor son algo chafas, 27mhz 2 canales. Perfecto para probar el arducopter o algun otro proyecto open source de control de vuelo.

Lo primero es controlar los motores que tengo, para eso volvere a usar los L298. en las pruebas en protoboard se calientan bastante, creo usare el chasis como disipador y espero sea suficiente para mantenerlos durante 10 minutos de vuelo a temperatura adecuada ( no tengo multimetro decente para medir el consumo de los motores, me toca esperar sean adecuados ). pense en ponerle motores brushless y ESC pero si hago eso ya directamente me monto el quadcopter, asi que motores con escobillas.

Estos son los archivos eagle de la pcb.

Arduino 1.0.5 y la libreria ServoTimer2.h

Con la placa arduino ya funcional, y esperando los esc y motores, solo me queda seguir con el cerebro de la bestia, asi que me he puesto a instalar la libreria ServoTimer2.h en arduino. Para sorpresa mia no es compatible con el nuevo entorno arduino 1.0 y he tenido que buscar una version modificada que si lo sea.

La libreria: ServoTimer2



Agradecimientos a codigo

Arduino Stand-Alone II (usbtinyisp)

Podria sacar de la pcb Quadcopter_V0 el chip Atmega328 cada vez que quisiera modificar la programacion, pero seria mucho estres mecanico innecesario. Mi placa ni tiene ni tendra usb, asi que le he habilitado a la placa patillaje para ISP.

MISO   1------- 2 VCC          miso pin18,vcc pin7
SCK     3------- 4 MOSI        sck pin19, mosi pin17
RESET 5------- 6 GND          reset pin1, gnd pin8

Placa

Esquema

PDF

Arduino Stand-Alone

Como en cada proyecto, la idea de construir algo es, que en el camino pueda aprender todo lo posible. Por eso estoy diseñando una placa arduino especifica para Quadcoper_V0, seria mucho mas rapido y facil comprar algunos de los sistemas, pero prefiero orientar también este proyecto hacia el aprendizaje  .

El circuito en protoboard (el led rgb indicador de corriente es lo mas xD  )

De momento es solo una placa arduino con convertidor de voltaje a 5v, led indicador de alimentacion y led en pin13. Dejo la pcb y diagramas en Eagle, tambien un pdf para imprimir.

Eagle sch

Eagle brd

Eagle Pdf

Agradecimientos a http://txapuzas.blogspot.mx/

MMA7260 y Arduino

Tengo un acelerometro de 3 ejes MMA7260 y  estoy experimentando con el, pero creo que no es lo apropiado para estabilizar a Quadcopter V0. Estoy buscando un Wii motion plus a buen precio para quitarle los giroscopios y usar estos en el proyecto.

El codigo inicial  del acelerometro mma7260 fue sacado de aqui:

Y aqui la primera modificacion

#define DEBUGMODE
#define _360div2xPI     57.29577951
#define _5000div1023    4.887585533
#define MMA7260_RESOLUTION      800     //0.8 v/g -> resolucion de 1.5g -> 800mV/g
#define MMA7260_VOLTAGE         3300.0; //mv voltage al que está conectado el acelerómetro
const float ZOUT1G = 2450;   // mv Voltage en Zout a 1G
const float ZOUT0G = 1650;   // mv Voltage en Zout a 1G
#define MMA7260_ZOUT_1G 850   // mv Voltage en Zout a 1G
const float XOUT1G = 2450;   // mv Voltage en Zout a 1G
const float XOUT0G = 1650;   // mv Voltage en Zout a 1G
const float YOUT1G = 2450;   // mv Voltage en Zout a 1G
const float YOUT0G = 1650;   // mv Voltage en Zout a 1G
#define NADJ  50        // Número de lecturas para calcular el error
// Entradas analógicas donde van los sensores
#define XAXIS_PORT  0
#define YAXIS_PORT  1
#define ZAXIS_PORT  2
// Salida digital del led de la placa
#define LEDPIN_PORT  13
float XError,YError,ZError;
float z,x,y;
float AccelAdjust(int axis)
{
  float acc = 0;
  for (int j=0;j < NADJ;j++)
  {
    float lectura=analogRead(axis);
    acc = acc + (lectura*_5000div1023);
    delay(11); //número primo para evitar ciclos de lectura proporcionales
  }
  return acc/NADJ;
}
void setup()
{
  Serial.begin(9600); // 9600 bps
  pinMode(XAXIS_PORT,INPUT);
  pinMode(YAXIS_PORT,INPUT);
  pinMode(ZAXIS_PORT,INPUT);
  pinMode(LEDPIN_PORT, OUTPUT);
  digitalWrite(LEDPIN_PORT, HIGH);
  XError =  AccelAdjust(XAXIS_PORT);
  YError =  AccelAdjust(YAXIS_PORT);
  ZError =  AccelAdjust(ZAXIS_PORT);
  ZError = ZError - MMA7260_ZOUT_1G;
  digitalWrite(LEDPIN_PORT, LOW);
#ifdef DEBUGMODE
  Serial.println("Ajustado acelerometro eje X");
  Serial.print("Error de X= ");
  Serial.println(XError);
  Serial.println("Ajustado acelerometro eje Y");
  Serial.print("Error de Y= ");
  Serial.println(YError);
  Serial.println("Ajustado acelerometro eje Z");
  Serial.print("Error de Z= ");
  Serial.println(ZError);
#endif
}
void loop()
{
  x=analogRead(XAXIS_PORT);
  y=analogRead(YAXIS_PORT);
  z=analogRead(ZAXIS_PORT);
  unsigned long tt = micros();
  float aax = ((x*_5000div1023)-XError)/MMA7260_RESOLUTION;
  float aay = ((y*_5000div1023)-YError)/MMA7260_RESOLUTION;
  float aaz = ((z*_5000div1023)-ZError)/MMA7260_RESOLUTION;
  float rho = atan(aax/sqrt((aay*aay)+(aaz*aaz)))*_360div2xPI;
  float phi = atan(aay/sqrt((aax*aax)+(aaz*aaz)))*_360div2xPI;
  float theta = atan(sqrt((aay*aay)+(aax*aax))/aaz)*_360div2xPI;
  tt = micros()-tt;
#ifdef DEBUGMODE
  /* Serial.print(" x");
  Serial.print(aax);
  Serial.print(" y ");
  Serial.print(aay);
  Serial.print(" z");        
  Serial.print(aaz);
  Serial.println();
  Serial.println(); */
  Serial.print("X  ");
  Serial.print(rho);
  Serial.print("   Y  ");
  Serial.print(phi);
  Serial.print("   Z  ");
  Serial.print(theta);
  Serial.println();
// Serial.print("mS");
// Serial.print(tt);
#endif
  delay(1000);
}