Panorama Robot 1.7 , el programa

Quizás, y para estar un poco a la moda le podría llamar 2.0 y hasta 3.0 , aunque en realidad el programa es el mismo de la versión 2011-2012 del robot original, este ha sufrido ligeros cambios y correcciones. En realidad tampoco le debería llamar 1.7, le podría decir versión 2013 y no por el año en que estamos sino por los pequeños cambios que he hecho desde finales del 2011 semana tras semana hasta que funcionara y tuviera un  mejor aspecto. A dia de hoy creo que me funciona todo y que es posible que deba de corregir cosas, pero para los inquietos ya pueden ir copiando y haciendo sus modificaciones pertinentes.

Actualmente está volcado en un ChipKit 32 y si no recuerdo mal, excede de los 34kb.

Algunos de los errores corregidos respecto la versión inicial han sido :

·      * Cuando el lcd mostraba el % del proyecto llegaba a un punto en que este valor de volvía loco. @engeeknyer me dio la solución : cambia el int por un long int .

·     * Ya no utilizo mi “keypad” casero, ahora todas las entradas de posicionamiento y validación funcionan mediante el LCD Shield con el que gano espacio, peso y orden.

·     * Antes el robot se pasaba un paso al final de cada línea , se ha corregido modificando el programa.

·      * Antes cuando terminaba toda la secuencia de fotografías, el robot al cabo de un rato reiniciaba sólo el ciclo. Ahora se quita todo del loop y al final se queda el sistema bloqueado hasta que le provoquemos un reset.

·       * Optimización de tiempos de espera entre movimientos. Aproximadamente se ha “regateado” entre 1-1.5 segundos/foto.

Las nuevas implementaciones:

·      

*  * Se programa mediante el uso de varias subrutinas, trabajando el programa en diferentes bloques, según como se mire es más fácil de entender dónde empieza y dónde acaba cada cosa.

·      * Se puede modificar la focal, antes era focal fija definida por variable.

·      * Se puede elegir el formato de cámara entre 4 modelos diferentes y comunes  de formato que hay en el mercado. Viendo el programa es fácil modificar e incluir otros.

    * Dado que tenemos más posibilidad de definir parámetros mediante el uso del Shield LCD, provoca que existan más variables “automatizadas” como:

·      * Calculo automático del ángulo , provocando que se deba auto-definir los impulsos que deben dar hacia los motores paso a paso.

·      * Calculo automático del tiempo de duración del proyecto ya que el tiempo entre capturas no es el mismo al variar los ángulos y tiempos de desplazamiento.

NOTA > Por si hay alguien que se quiere “copiar” el proyecto, informaros que debido a un problema con la Shield LCD tuve que insertar una resistencia entre el pulsador de SELECT y la entrada AnalogRead(A0) ya que no me respondía esta tecla.

Cabecera del programa: Sirve para anotar informaciones que no afectaran al funcionamiento del programa pero que nos puede servir para tenerlas junto al programa cuando lo grabamos. Muchas veces nos puede servir para hacernos recordar que es lo que hace el programa, sobretodo cuando no ponemos títulos muy claros a la hora de guardar el programa.

/*

 Photo Robot 2x L298N + Nema 17

 language: Wiring/Arduino

 This program drives two bipolar stepper motor.

 Photo-shots signals it's actuated by relay --

 Movement manual motor by array switchs of keypad

 Created 28 Dec. 2012

 Last updated 13 Feb. 2013

 v1.7

 by XavierGP

 */

Habilitar uso de librerias y constantes: Una librería es un conjunto de instrucciones que no viene por defecto en la programación de Arduino y que nos simplificaran mucho el trabajo y tamaño del proyecto. En este caso incluimos la librería Stepper.h que hace referencia al movimiento de los motores paso a paso , y la librería LiquidCrystal.h que es la encargada de facilitarnos la faena a la hora de mostrar caracteres en la Shield LCD.

También aprovechamos para definir las siguientes constantes:

·      _360div2xPI la utilizaremos para convertir los angulos de radianes a formato estandar de una vuelta de 360º.

·      motorStepsX es el numero de impulsos que debe dar nuestro motor paso a paso para dar una vuelta, es un valor que en principio nos lo debe dar el fabricante. En este caso lo usaremos para el motor del movimiento horizontal (eje X). En nuestro caso corresponde a 200 impulsos.

·      motorStepsY lo mismo que la anterior constante motorStepsX, pero en este caso es para el motor del movimiento horizontal.

·      fan se trata del numero de salida del Arduino que da orden de funcionamiento del ventilador de refrigeración de los drivers del motor (2x L298N)

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

#include <LiquidCrystal.h>  // incluimos la LiquidCrystal LCD library

#define _360div2xPI     57.29577951

#define motorStepsX 200     // Pasos motor X 360º/1.8º

#define motorStepsY 200     // Pasos motor Y 360º/1.8º                     

#define fan 29              // Pin OUT 29 habilita tensión en ventilador disipador

Definición de variables: definimos las variables que vamos a utilizar. A diferencia de las constantes esto son valores que puede ser que se modifiquen en el transcurso del programa.

·      pulsosvueltaejeX : es el numero de pulsos que debemos dar al motor para que de una vuelta entera el eje X. En teoria deberia ser 200 multiplicado por la reducción que tengamos. Yo preferí generarme un programa para determinar con exactitud el numero de impulsos para dar una vuelta entera.

·       pulsosvueltaejeY: idem , como en pulsosvueltaejeX pero para el motor del movimiento vertical (eje Y).  En mi caso fueron 6444 impulsos.

·       impX es el numero de impulsos que corresponden a 1 grado del ejeX

·       impY es el numero de impulsos que corresponden a 1 grado del ejeY

·       pasoX son los impulsos que realizará entre capturas del eje X y que tiene relación entre los grados que hay en el eje horizontal entre diferentes capturas.

·       pasoY idem pasoX pero para el eje vertical.

·       xact posición actual en grados del eje X.

·       yact posición actual en grados del eje Y.

·       xmax hace referencia a la posición máxima de la captura expresada en grados del eje X.

·       xmin hace referencia a la posición mínima de la captura expresada en grados del eje X.

·       ymax hace referencia a la posición máxima de la captura expresada en grados del eje Y.

·       ymin hace referencia a la posición mínima de la captura expresada en grados del eje Y.

·       xtemp posición actual del robot en grados del eje X.

·       ytemp posición actual del robot en grados del eje Y.

·       nshot numero de foto actual del proyecto.

·       filasX (debería de ser columnas en realidad…) es el numero de fotos a realizar en cada fila horizontal.

·       filasXX usada como variable temporal.

·       columnasY es el numero de todas las filas.

·       columnasYY usada como variable temporal.

·       previsionShot numero total de fotografías a realizar durante el proyecto.

·       segundos duración del proyecto expresada en segundos.

·       minutos duración del proyecto en minutos.

·       horas duración del proyecto en horas.

·       pause variable para mantener o reanudar una pausa.

·       analogico0 es el valor correspondiente a la lectura analógica numero 0 correspondiente a los valores entregados por los diferentes pulsadores de la Shield LCD.

·       temperatura valor de temperatura corregido.

·       voltage es el valor entregado por la bateria usando un divisor de tensión para tener un control sobre la misma.

·       valorTemp lectura del LM35DT encargado de mostrarnos la temperatura del disipador de los drivers L298N.

·       progreso es el valor en % del proyecto realizado.

·       abajo es el valor de la entrada analogica 0 correspondiente al pulsador DOWN.

·       arriba es el valor de la entrada analogica 0 correspondiente al pulsador UP.

·       enter  es el valor de la entrada analogica 0 correspondiente al pulsador SELECT.

·       left es el valor de la entrada analogica 0 correspondiente al pulsador LEFT.

·       right es el valor de la entrada analogica 0 correspondiente al pulsador RIGHT.

·       margen es el valor de la tolerancia que le damos al valor de los pulsadores.

·       d1 es el valor del lado largo del sensor fotografico CMOS expresado en mm.

·       d2 es el valor del lado alto del sensor fotografico CMOS expresado en mm.

·       diagonal_sensor es la diagonal resultante (hipotenusa) del triangulo d1 d2.

·       grados_horizontales es el valor resultante a la variables focal y factor (multiplicación o recorte) en horizontal.

·       grados_verticales es el valor resultante a la variables focal y factor (multiplicación o recorte) en vertical

·       factor es el factor multiplicación o recorte del sensor CMOS.

·       focal es el valor de la focal del objetivo que utilizaremos.

·       paso es una variable que nos ayudará a ir más rápido a la hora de definir la focal. Cuanto mas grande es el factor focal , más incrementa el paso (para no subir todo el rato en pasos de un milímetro)

·       menu es una variable para memorizar el tipo de formato de cámara usado.

·       logo1a – logo1h sirven para definir el gif de la presentación del inicio, en grupos de 5 columnas x 8 filas de pixeles, dónde un 0 es píxel apagado, y un 1 píxel oscuro.

int pulsosvueltaejex=10180;           // 200impulsos x reduccion mecanica

int pulsosvueltaejey=6444;            // 200impulsos x reduccion mecanica

float impX=pulsosvueltaejex/360;      // número de impulsos que corresponden a 1º del eje X   51.9*200/360  

float impY=pulsosvueltaejey/360;      // número de impulsos que corresponden a 1º del eje Y   32.2*200/360

int pasoX;                            // pasos motor entre capturas eje X

int pasoY;                            // pasos motor entre capturas eje Y 

float xact;               // º actual eje X

float yact;               // º actual eje Y

float xmax;               // º posición máxima eje X

float xmin;               // º posición mínima eje X

float ymax;               // º posición máxima eje Y

float ymin;               // º posición mínima eje Y

int xtemp;

int ytemp;

int nshot;

int filasX;                 // número de filas eje X >> (xmax-xmin)/pasoX

int filasXX;

int columnasY;              // número de columnas eje Y    >> (ymax-ymin)/pasoY

int columnasYY;

int previsionShot;          // prevision número shots   filasX * columnasY

int segundos ;

int minutos ;

int horas ;

int pause;

int analogico0;     // variable to store the value coming from the keypad

float temperatura;  // variable to store the value of radiator

float voltage;      // variable to store the voltage battery supply

float valorTemp;

int progreso;

int abajo=450;      //definimos valores teclas

int arriba=210;

int enter=945;

int left=680;

int right=0;

int margen=50;    //abans era 30

float d1;         // distancia 1 sensor CMOS (ancho)

float d2;         // distancia 2 sensor CMOS (alto)

float diagonal_sensor;

float grados_horizontales;

float grados_verticales;

float factor;     // en su defecto : FF = 1, Nikon DX=1.5 , Canon DX=1.6 , Olympus= 2

float focal = 700; 

int paso;

int menu=2;

byte logo1a[8] = {B01111, B00110, B01111, B11111, B11111, B11111, B11110, B11110};

byte logo1d[8] = {B00000, B00000, B11110, B11111, B11111, B11111, B11111, B11111};

byte logo1e[8] = {B11110, B11110, B11110, B11111, B11111, B11111, B11111, B01111};

byte logo1h[8] = {B01111, B01111, B01111, B11111, B11111, B11111, B11111, B11110};

Inicialización de comandos: Direccionamos las entradas/salidas que corresponden a cada librería y a cada salida. En este caso definimos las dos salidas de los Steppers y luego las salidas correspondientes al LCD.

variables que vamos a utilizar. Seguidamente le decimos que el pin 28 lo utilizaremos como una salida al igual que el pin fan (definido en variables como numero 29), y acto seguido le decimos que por defecto queremos que estén en LOW (salidas apagadas). Acto seguido habilitamos la velocidad de los dos steppers al valor de 20 y también “arrancamos” el LCD.

Stepper myStepperX(motorStepsX, 31, 32, 30, 33); //  initialize the library motor X

Stepper myStepperY(motorStepsY, 38, 41, 39, 40); // initialize the library motor Y

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);  // initialize the library with the numbers of the interface pins

void setup() {

pinMode(28, OUTPUT);      // Output digital  shot

pinMode(fan, OUTPUT);     // Output digital  fan

digitalWrite(28, LOW);

digitalWrite(fan,LOW);

myStepperX.setSpeed(20);  // set the motor X speed at 15 RPMS:

myStepperY.setSpeed(20);  // set the motor Y speed at 10 RPMS:

 

lcd.begin(16, 2);

Creamos los caracteres en base a las variables logo1a,1d,1e y 1h:

lcd.createChar(1, logo1a);

lcd.createChar(4, logo1d);

lcd.createChar(5, logo1e);

lcd.createChar(8, logo1h);

Ejecutamos las subrutinas presentacioninicio y defineparametro: lease presentacioninicio y defineparametro . Estas subrutinas se encargan de que nos aparezca el mensaje de bienvenida con el logo de la cámara fotográfica y de definir los parámetros por el usuario correspondiente al formato de cámara y focal que utilizaremos.

presentacioninicio();

defineparametro();

Determinación de los puntos inicio y final de la panorámica: mediante la ayuda de dos subrutinas buscaorigen y buscafinal servirá para determinar la cobertura de nuestra foto. El programa está pensado para que el valor final tanto en X como de Y sea superior al final , es decir si entendemos que la posición inicial seria la esquina inferior izquierda de la fotografía y el punto final seria la esquina superior derecha. El programa NO está pensado para trabajar en otras opciones (habría que mejorarlo o probarlo como responde). Empezamos borrando la pantalla y apareciendo mediante un scroll lateral las instrucciones para localizar el punto de inicio (esquina inferior izquierda): mover mediante flechas y validar con tecla Select. Una vez validado nos aparecerá un mensaje de confirmación, y nos invitará a buscar el punto final (esquina superior derecha) mediante la subrutina buscafinal.  De toda esta parte acabaremos obteniendo el valor de filas y columnas totales.

lcd.clear();

lcd.print("Define posicion origen mediante flechas");

delay (1000);

for (int positionCounter = 0; positionCounter < 23; positionCounter++) {

lcd.scrollDisplayLeft(); // scroll one position left:

delay(350);              // wait a bit:

}

delay (1000);

lcd.setCursor(23,1);

lcd.print("[SELECT]  valida");

delay (3000);

buscaorigen();

lcd.clear();

lcd.print("Define posicion final mediante flechas");

delay (1000);

for (int positionCounter = 0; positionCounter < 22; positionCounter++) {

lcd.scrollDisplayLeft();    // scroll one position left:

delay(350);                 // wait a bit:

}

delay (1000);

lcd.setCursor(22,1);

lcd.print("[SELECT]  valida");

delay (3000);

buscafinal();

xact=-xmin;

yact=-ymin;

filasX=((xmax-xmin)/pasoX)+1;

filasXX=filasX;

columnasY=((ymax-ymin)/pasoY)+1;

columnasYY=columnasY;

Una vez tenemos el numero de filas y columnas es fácil determinar el numero de capturas (previsionShot) pues es una simple multiplicación, y a continuación calcularemos el tiempo requerido para realizar el proyecto en segundos.

previsionShot=filasX*columnasY;

segundos=previsionShot+(0.5*(columnasY-1))+(0.04*(((columnasY-1)*pasoY)+((filasX-1)*columnasY*pasoX))); 

Nuestro robot se mueve hacia el punto de origen mientras el LCD se borra varias veces y nos informa del numero de capturas, filas, columnas y grados correspondientes.

lcd.clear();

lcd.print("Moviendo a posicion de inicio         ");

lcd.setCursor(0,1);

lcd.print("<<< << <   < < <    < <     <         ");

delay(500);

for (int positionCounter = 0; positionCounter < 23; positionCounter++) {

lcd.scrollDisplayLeft(); // scroll one position left:

delay(350);              // wait a bit:

}

lcd.clear();

lcd.print("espera...");

myStepperX.step(-(filasX-1)*pasoX);

myStepperY.step(-(columnasY-1)*pasoY);   

lcd.clear();

lcd.print("Home position !");

delay(3000);

lcd.clear();

lcd.print(previsionShot);

lcd.print(" capturas:");   

lcd.setCursor(0, 1);

lcd.print(filasX);

lcd.print("H * ");

lcd.print(columnasY);

lcd.print("V");

delay (5000);

lcd.setCursor(0,1);

  

lcd.print((-xmin+xmax)/impX);

lcd.print(char(223));

lcd.print("H ");

lcd.print((-ymin+ymax)/impY);

lcd.print(char(223));

lcd.print("V     ");

delay (5000);

 

Ejecutamos la subrutina conversiontiempo para que nos pueda expresar la duración del proyecto en horas, minutos y segundos . Léase conversiontiempo.

conversiontiempo();

Tenemos todas las variables definidas y nuestro robot a punto, sólo falta que pulsemos SELECT para iniciar. El LCD nos informa de cómo empezar y como pausar el proyecto.

lcd.clear();

lcd.print("Pulse [SELECT] para iniciar y para pausar ");

lcd.setCursor(0,1);

lcd.print("               ");

delay (1000);

for (int positionCounter = 0; positionCounter < 24; positionCounter++) {

lcd.scrollDisplayLeft();   // scroll one position left:

delay(350);                // wait a bit:

}

delay(2000);

lcd.clear();

lcd.setCursor(0,1);

lcd.print("[SELECT] = start");

pause=1;

while(pause!=0){

if((analogRead(0)/margen)==(enter/margen)){   // Tecla SELECT

pause=0;

}

}

xmax=xmax-xmin;

ymax=ymax-ymin;

xmin=0;

ymin=0;

xact=0;

yact=0;

 

Rutina de captura de fotografía: movimiento de motores: Empieza el ciclo disparando una foto y acto seguido el robot se mueve en sentido hacia la derecha un PasoX (grados resultantes de la focal y factor cámara definidos) y a continuación otra foto hasta llegar al valor máximo programado como valor máximo de X (numero de filasX), momento en que retrocederá el robot hasta el punto de inicio e incrementará el ángulo en el eje vertical un PasoY antes de empezar otra vez a realizar todas las fotos de la misma fila.

for(int i=0; i<columnasY; i++){      // empieza secuencia panoramica        

delay(1000);

for(int j=0; j<(filasX-1); j++){   //FILASX

Analizamos la temperatura del disipador (señal del LM35) y decidimos si activamos el ventilador (temperatura superior a 33ºC) o si lo paramos (temperatura inferior a 29ºC)

temperatura=analogRead(A6);         // comprobamos temperatura en disipador LM35DT

valorTemp = ((500 * temperatura * 5 )/1024.0);

if(valorTemp<290){digitalWrite(fan,LOW);}              // deshabilita tensión en ventilador - energy saving - si temperatura < 29ºC

if(valorTemp>330){digitalWrite(fan, HIGH);}            // habilita tensión en ventilador si temperatura > 33ºC

Activamos la señal hacia el disparador remoto de la camara durante 500 ms.

digitalWrite(28, HIGH);

delay(500);                         // original 500 aquest timer es pot reduir !!!!!!!!!!!!!!!

nshot=nshot++;

mientras ejecuta el proyecto, en el LCD nos muestra el progreso, numero de foto , la fila y la columna.

lcd.clear();

progreso=((nshot*100)/(previsionShot));

lcd.print(progreso);

lcd.print("%");

lcd.setCursor(7,0);

lcd.print("X:   Y:");

lcd.setCursor(0,1);

lcd.print(nshot);

lcd.setCursor(7,1);

lcd.print(j+1);

lcd.setCursor(12,1);

lcd.print(i+1);

desactivamos la señal del disparador remoto y analizamos si se está pidiendo de realizar una pausa en el proyecto (subrutina peticiopausa)

digitalWrite(28, LOW);

peticiopausa();  

delay(500);

if(j!=(filasX+0)){  

myStepperX.step(pasoX);

xact=xact+(pasoX);

}

delay(500);                                                                                 // original 750 aquest timer es pot reduir !!!!!!!!

}

nshot=nshot++;

digitalWrite(28, HIGH);

lcd.clear();

progreso=((nshot*100)/(previsionShot));

lcd.print(progreso);

lcd.print("%");

lcd.setCursor(7,0);

lcd.print("X:   Y:");

lcd.setCursor(0,1);

lcd.print(nshot);

lcd.setCursor(7,1);

lcd.print(filasX);

lcd.setCursor(12,1);

lcd.print(i+1);

delay(500);                         // original 500 aquest timer es pot reduir !!!!!!!!!!!!!!!

digitalWrite(28, LOW);

delay(500);

una vez llegamos a la ultima captura de cada fila, el LCD nos mostrará la temperatura del disipador y el voltage de la bateria mediante una llamada a la subrutina pantallatemperatura a la vez que el robot retorna al origen en X y acto seguido incrementa un paso en el eje Y.

pantallatemperatura();

      

myStepperX.step((-(filasXX)+1)*pasoX);   //////////////+0

xact=0;

if(i!=columnasY-1){myStepperY.step(pasoY);}                                

yact=yact+(pasoY);

delay(1000);

}

Una vez se han completado todas las filas, columnas y fotos, tan sólo nos queda esperar a que el robot vuelva a la posición inicial y nos aparezca el mensaje de “Panorámica Completa ! “ y acto seguido entraremos en un loop del cual es imposible salir hasta que no pulsemos el botón de reset, con esto evitaremos reinicios automáticos como hacia la versión anterior de este programa. Ahora ya sólo nos queda procesar todas las capturas en nuestro ordenador.

lcd.clear();

lcd.print("Panoramica");

lcd.setCursor(5,1);

lcd.print("completa !!");

myStepperY.step((-columnasYY+1)*pasoY);

}

void loop(){

}

Subrutina defineparametro: En esta subrutina vamos a definir el tipo de cámara réflex que usamos. En principio se han programado los 4 tipos más conocidos según el formato de recorte (Full Frame, Nikon DX, Canon DX y Olympus 4/3). Es muy fácil insertar más tipos, tan solo tocará buscar las medidas de los sensores CMOS y calcular su diagonal. En esta programación por defecto parto de que utilizaré una Nikon DX y un zoom de 700mm. Si queréis definir otra tan sólo hay que cambiar los valores en las variables al inicio del programa.

void defineparametro(){ // rutina definimos tipo de camara y focal

lcd.clear();

lcd.print(" Formato camara");

lcd.setCursor(2, 1);

lcd.print("[UP] & [DOWN]");

delay(1500);

while((analogRead(0))/margen!=(enter/margen)){ //enter

delay(300);

if((analogRead(0)/margen)==(arriba/margen)){  //arriba

menu=menu+1;

if(menu>=4){menu=4;}

lcd.clear();

}

if((analogRead(0)/margen)==(abajo/margen)){   //abajo

menu=menu-1;

if(menu<=1){menu=1;}

lcd.clear();

}

if(menu==1){ // FF

lcd.print("Full Frame 35 mm.");

d1=35.8;         //canon 5d

d2=23.9;         //canon 5d

factor=1;

diagonal_sensor=43.0447441623248;

}

if(menu==2){ // Nikon DX

lcd.print(" Nikon DX  1.5x");

factor=1.5;

d1=23.6;         // distancia 1 sensor CMOS (ancho)   Valor de la Nikon d90 !

d2=15.8;         // distancia 2 sensor CMOS (alto)    Valor de la Nikon d90 !

diagonal_sensor=28.40070421662111;

}

if(menu==3){ // Canon DX

lcd.print(" Canon DX  1.6x");

factor=1.6;

d1=22.2;         // eos1000d

d2=14.8;         // eos1000d

diagonal_sensor=26.68107943843352;

}

if(menu==4){ // Olympus 4/3

lcd.print("Olympus 4/3   2x");

factor=2;

d1=17.3;         // e-520

d2=13.0;         // e-520

diagonal_sensor=21.6400092421422;

}

lcd.setCursor(0, 1);

lcd.print("[SELECT]  valida");

}

En la segunda parte de esta subrutina, definiremos la focal que vamos a utilizar. Aquí se utiliza la variable paso que tiene la función de cambiar el incremento de la focal a medida que va creciendo o decreciendo el valor con la finalidad de tener velocidad a la hora de ajuste sin perder precisión en el valor.

lcd.clear();     // rutina definimos focal

lcd.print("Longitud  focal:");

lcd.setCursor(2, 1);

lcd.print("[UP] & [DOWN]");

delay(1500);

while((analogRead(0))/margen!=(enter/margen)){ //enter

if (focal<100){

paso=1;

delay(75);

}

if (focal>=100){

paso=25;

delay(120);

}

if (focal>399){

paso=50;

delay(150);

}

if((analogRead(0)/margen)==(arriba/margen)){  //arriba

focal=focal+(paso);

lcd.clear();

}

if((analogRead(0)/margen)==(abajo/margen)){   //abajo

if(focal>1){focal=focal-(paso);}

lcd.clear();

}

lcd.print(focal);

lcd.print(" mm.");

lcd.setCursor(0, 1);

lcd.print("[SELECT]  valida");

}

// diagonal_sensor=sqrt((d1*d1)+(d2*d2));

//factor =35/d1;

Seguidamente y haciendo uso de las variables de focal y el formato de cámara, el programa calculará la equivalencia en grados tanto en vertical como en horizontal (en principio la programación esta pensada en que la  cámara esté situada en horizontal!), y acto seguido recalculará cuantos impulsos debe ejercer en cada uno de los dos motores para lograr un solape optimo).

grados_horizontales= 2* (atan(diagonal_sensor/(2*focal*factor))*_360div2xPI);

grados_verticales = grados_horizontales * d2 / d1;

pasoX=(pulsosvueltaejex*(grados_horizontales/360));

pasoY=(pulsosvueltaejey*(grados_verticales/360));

lcd.clear();

lcd.print ("Focal equivalente");

lcd.setCursor(2, 1);

lcd.print(focal*factor);

lcd.setCursor(10, 1);

lcd.print("mm.");

delay(3000);

}

Subrutina presentacioninicio: básicamente es la presentación del inicio dónde nos da la bienvenida el LCD y acto seguido muestra la versión del programa y un gif animado de una cámara haciendo una foto. Dentro de esta subrutina, llamaremos a otras dos logo2 y logo3 que es dónde contiene parte de la programación del gif. Según mis pruebas sólo pueden haber 8 caracteres definidos por el usuario a la vez, es por ello que utilizo subrutinas para acortar el programa.

void presentacioninicio(){

lcd.clear();

lcd.print(" Hola XavierGP!");

delay(3000);

lcd.clear();

lcd.setCursor(0,0);

lcd.print("Panorama");

lcd.setCursor(0,1);

lcd.print("Robot");

logo3();

delay(800);

logo2();

delay(400);

logo3();

lcd.setCursor(6,1);

lcd.print("v1.7");

delay(800);

logo2();

delay(400);

logo3();

delay(3000);  // fin GIF

}

void logo2(){

byte logo1b[8] = {B00000, B00111, B11100, B10001, B00111, B01111, B01111, B11111};

byte logo1c[8] = {B00000, B11100, B00111, B10001, B11100, B11110, B11110, B11111};

byte logo1f[8] = {B11110, B11111, B01111, B01111, B00111, B10001, B11100, B11111};

byte logo1g[8] = {B01111, B11111, B11111, B11110, B11100, B10001, B00111, B11111};

byte logo1d[8] = {B00000, B00000, B11110, B11111, B11111, B11111, B11111, B11111};

lcd.createChar(2, logo1b);

lcd.createChar(3, logo1c);

lcd.createChar(6, logo1f);

lcd.createChar(7, logo1g);

lcd.createChar(4, logo1d);

lcd.setCursor(12,0);

lcd.write(1);

lcd.setCursor(13,0);

lcd.write(2);

lcd.setCursor(14,0);

lcd.write(3);

lcd.setCursor(15,0);

lcd.write(4);

lcd.setCursor(12,1);

lcd.write(5);

lcd.setCursor(13,1);

lcd.write(6);

lcd.setCursor(14,1);

lcd.write(7);

lcd.setCursor(15,1);

lcd.write(8);

}

void logo3(){

byte logo1b[8] = {B00000, B00111, B11100, B10001, B00110, B01100, B01000, B10000};

byte logo1c[8] = {B00000, B11100, B00111, B10001, B01100, B00110, B00010, B00001};

byte logo1f[8] = {B10000, B10000, B01000, B01100, B00110, B10001, B11100, B11111};

byte logo1g[8] = {B00001, B00001, B00011, B00110, B01100, B10001, B00111, B11111};

byte logo1d[8] = {B00000, B00000, B11110, B11111, B11111, B11111, B11111, B11111};

lcd.createChar(2, logo1b);

lcd.createChar(3, logo1c);

lcd.createChar(6, logo1f);

lcd.createChar(7, logo1g);

lcd.createChar(4, logo1d);

lcd.setCursor(12,0);

lcd.write(1);

lcd.setCursor(13,0);

lcd.write(2);

lcd.setCursor(14,0);

lcd.write(3);

lcd.setCursor(15,0);

lcd.write(4);

lcd.setCursor(12,1);

lcd.write(5);

lcd.setCursor(13,1);

lcd.write(6);

lcd.setCursor(14,1);

lcd.write(7);

lcd.setCursor(15,1);

lcd.write(8);

}

Subrutina conversiontiempo: Tal y como dice el nombre, esta subrutina sólo tiene la finalidad de convertir el tiempo de duración del proyecto que teníamos en formato segundos a formato horas, minutos y segundos.

void conversiontiempo(){  // convertimos tiempo necesario en realizar proyecto

while(segundos>=3600){  

horas = horas++;

segundos = segundos - 3600;

}

while(segundos>=60){

minutos = minutos++;

segundos = segundos - 60;

}

lcd.clear();

lcd.print("Duracion prevista");

lcd.setCursor(0,1);

lcd.print(horas);

lcd.print("hrs ");

lcd.print(minutos);

lcd.print("min ");

lcd.print(segundos);

lcd.print("seg");

delay(5000);

}

Subrutina pantallatemperatura: esta es la pantalla que nos mostrará el LCD cuando está retornando el robot a la columna de inicio. Podremos ver la temperatura del disipador y el voltaje de la batería a modo de información. En el valor de voltaje he tenido de corregirlo para que se asemejara lo más posible a mi realidad.

void pantallatemperatura(){

lcd.clear();

lcd.print("Voltage ");

voltage=analogRead(A7)*1.212;

lcd.print(voltage/100);  

lcd.print(" v.");

lcd.setCursor(0,1);

lcd.print("Temp.:  ");

lcd.print(valorTemp/10);

lcd.print(" ");

lcd.print(char(223));

lcd.print("C");

}

Subrutina peticiopausa: preguntamos al pic si hay la entrada analógica 0 en valor de Select durante 10 veces y si es asín provocamos una pausa forzada de 10 segundos antes no podamos volver a pulsar la misma tecla para reprender con nuestro proyecto fotográfico. El por que de las 10 veces es porque me he encontrado que o el pic corre mucho y “no se entera” o el valor no era el exacto al programar la pausa.

void peticiopausa(){

for (int k=0; k<10; k++){ //prova pausa

if((analogRead(0)/margen)==(enter/margen)){     // tecla SELECT si apretem provoquem una pausa fins que no apretem ENTER

lcd.clear();

lcd.print("Pausa!");

lcd.setCursor(0,1);

lcd.print("[SELECT]=reStart");

delay(10000);  //abans no hi era i em rearrancaba

pause=2;

while(pause>1){

if((analogRead(0)/margen)==(enter/margen)){   // tecla SELECT

pause=0;

lcd.clear();

lcd.print("SHOT   X:   Y:");

delay(1000);

}

}

}

} //prova pausa

}

Subrutina buscaorigen: hasta que no pulsemos select no nos validará la posición que deseemos y que podemos desplazar mediante el uso de los pulsadores up, down, left y right mediante la subrutina movimiento. A continuación memorizará estos valores como la xmin y la ymin.

void buscaorigen(){

while((analogRead(A0)/margen)!=(enter/margen)){

movimiento();

}

xmin=xact;

ymin=yact;

lcd.clear();

lcd.print("Posicion  origen");

lcd.setCursor(0, 1);

lcd.print(" - CONFIRMADA - ");

delay(3500);

}

Subrutina buscafinal: lo mismo que en buscainicio pero definiremos el punto final de nuestras capturas, memorizándolos como xmax e ymax.

void buscafinal(){

while((analogRead(A0)/margen)!=(enter/margen)){

movimiento();

}

xmax=xact;

ymax=yact;

lcd.clear();

lcd.print("Posicion  final");

lcd.setCursor(0, 1);

lcd.print(" - CONFIRMADA - ");

delay(3500);

}

 

Subrutina movimiento: tiene la función de hacer mover el robot manualmente mediante los pulsadores up, down, left y right y acto seguido informándonos en el LCD la posición del mismo.

void movimiento(){

analogico0 = analogRead(A0);   

if((analogRead(A0)/margen)==(right/margen)) {xact=xact+pasoX;}    //  derecha +X

if((analogRead(A0)/margen)==(left/margen))  {xact=xact-pasoX;}    //  izquierda -X  

if((analogRead(A0)/margen)==(abajo/margen)) {yact=yact-pasoY;}    //   abajo -Y

if((analogRead(A0)/margen)==(arriba/margen)){yact=yact+pasoY;}    //   arriba +Y

lcd.clear();

lcd.print("X:      Y:");

lcd.setCursor(0, 1);

lcd.print(xact/impX);

lcd.print(char(223));

lcd.setCursor(8, 1);

lcd.print(yact/impY);

lcd.print(char(223));

myStepperX.step(xact-xtemp);

xtemp=xact;

myStepperY.step(yact-ytemp);

ytemp=yact;

delay(20);

                     }

Con todo esto ya tenemos el programa enterito y funcional, aunque seguro que muchos de vosotros podéis optimizarlo mucho más y corregir errores, todo es cuestión de pasarse horas pensando , modificando y probando.

Lógicamente no lo he probado con todas las focales y ni mucho menos con los 4 formatos de factor recorte , pero en teoría y repito: en teoría debería ir…

Personalmente creo que hay un error al no definir el solape entre capturas pero después de varias pruebas, aun no lo veo claro ! y como que es un proyecto personal sin ningún animo de lucro ni de proyecto de carrera ni nada que se le parezca creo que ya está bastante bien, al menos era la intención , pero todo conlleva mucho tiempo, horas ya sea haciendo agujeros, buscando material por eBay, documentando y buscando fórmulas, haciendo videos y luego editarlos, fotos, entrada al blog…na que hay un buen curro que espero que algunos sepáis valorar.

Finalmente os dejo un video en que podéis medio ver como funciona el tema de pantallas, deseo que os guste.

Tengo previsto alojar el programa entero en Internet, pero aun no tengo claro dónde para poder tener un control a título personal del número de descargas…¿alguna idea/propuesta?

¿ Alguien se anima a crear la versión 2.0 ?

Saludos a todos los visitantes!