CODIGO FINAL PROYECTO

Dependencies:   mbed MMA8451Q

Files at this revision

API Documentation at this revision

Comitter:
matirodriguez
Date:
Wed Nov 20 13:14:55 2019 +0000
Commit message:
CODIGO FINAL PROPYECTO;

Changed in this revision

MMA8451Q.lib Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
mbed.bld Show annotated file Show diff for this revision Revisions of this file
diff -r 000000000000 -r 1a9bfeb27157 MMA8451Q.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MMA8451Q.lib	Wed Nov 20 13:14:55 2019 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/emilmont/code/MMA8451Q/#c4d879a39775
diff -r 000000000000 -r 1a9bfeb27157 main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Wed Nov 20 13:14:55 2019 +0000
@@ -0,0 +1,2044 @@
+#include "mbed.h"
+#include "MMA8451Q.h"
+#define MMA8451_I2C_ADDRESS (0x1d<<1)
+#define HABILITADO 1
+#define DESHABILITADO 2
+#define NADA 0
+#define PASOS_MINIMOS 16
+#define APP 5
+#define CONTROL 6
+#define LOOP 7
+#define DERECHA 0
+#define IZQUIERDA 1
+#define MOVIENDO 1
+#define QUIETO 0
+#define VALORES_MOTOR 1
+#define VELOCIDAD_MOTOR 2
+#define MODO_DE_CONTROL 3
+#define CONF_LOOP 4
+#define MAX_SLIDE 62755
+#define MAX_TILT 3150
+#define MAX_PAN 3200
+#define PUNTO_E 5
+#define TIME_LAPSE 8
+
+/*
+    Loop
+
+*/
+
+enum {START,
+      SLIDE,
+      S1,
+      S2,
+      S3,
+      TILT,
+      T1,
+      T2,
+      T3,
+      PAN,
+      P1,
+      P2,
+      P3,
+      BOTONES,
+      B1,
+      B2,
+      CRC,
+      FIN,
+      V1,
+      INICIO,
+      V2,
+      HAB_JOYSTICK,
+      LOOP_HAB,
+      L_DELAY1,
+      L_DELAY2,
+      LD_UNIDAD,
+      L_TIMEOUT1,
+      L_TIMEOUT2,
+      LT_UNIDAD,
+      PUNTOE,
+      PRECISION,
+      TIMELAPSE,
+      T_LADO,
+      T_DURACION,
+      T_DURACION2,
+      T_UNIDAD,
+      T_MODO
+     };
+
+enum {
+    ESPERO, PASO, DELAY, RIGHT, LEFT, HOLD
+};
+
+
+AnalogIn ana(PTB0);
+
+// -------------- Manejo Slide
+
+DigitalOut Slide_dir(PTC7);
+DigitalOut Slide_step(PTC0);
+
+DigitalIn fc1(PTC13);
+DigitalIn fc2(PTC12);
+
+void MAQ_VSlide(int velocidad_deseada, int direccion);    //Maquina de estados que controlará el motor de slide por Velocidad ( usada por los joysticks )
+void timeoutVSlide();    // Funcion que será llamada por el Timeout que use para realizar los pasos del motor de slide
+void paso_VSlide();     // Funcion que será llamada por un ticker para que todos los pasos se realicen cada el mismo tiempo, y no dependiendo de la velocidad
+
+Ticker ticker_VSlide;   // Ticker que llamará la funcion paso_VSlide() cada 10ms
+Timeout VSlide;     // Timeout que usaré para cambiar de estado en la maquina de control por velocidad
+
+int estado_VSlide = ESPERO; // Variable que indica el estado en el que se encuentra la maquina de estados
+int hab_maq_VSlide = DESHABILITADO;  // Habilitacion de dicha maquina de estados
+int timeout_VSlide = DESHABILITADO;  // Variable que que se habilitará cuando el tiempo establecido en el Timeout se cumpla ( usada para cambiar de estado)
+int direccion_VSlide = DERECHA; // Variable que voy a usar para indicar la direccion que tendrá el giro del motor
+int velocidad_VSlide = 1;   // Variable que voy a usar para indicar la velocidad a la que quiero que se mueva el motor
+volatile int incremento_VSlide = DESHABILITADO;// Variable que voy a usar para realizar los pasos siempre cada el mismo tiempo, y no  cada vez mas rapido.
+int stop_VSlide = MOVIENDO;   // Variable que me indicará si el motor se esta moviendo o esta quieto, para poder cambiar de modo SOLO cuando se encuente quieto
+int intensidad_VSlide = 10; // Variable que indica el que tan rapido es el multiplicador de la velocidad del joystick ( Varia de 1 (lento) a 10 (rapido))
+
+// -------------- Manejo Tilt
+
+DigitalOut Tilt_dir(PTC4);
+DigitalOut Tilt_step(PTC3);
+
+DigitalIn opto_tilt(PTC2);
+
+void MAQ_VTilt(int velocidad_deseada, int direccion);    //Maquina de estados que controlará el motor de slide por Velocidad ( usada por los joysticks )
+void timeoutVTilt();    // Funcion que será llamada por el Timeout que use para realizar los pasos del motor de slide
+void paso_VTilt();     // Funcion que será llamada por un ticker para que todos los pasos se realicen cada el mismo tiempo, y no dependiendo de la velocidad
+
+Ticker ticker_VTilt;   // Ticker que llamará la funcion paso_VSlide() cada 10ms
+Timeout VTilt;     // Timeout que usaré para cambiar de estado en la maquina de control por velocidad
+
+int estado_VTilt = ESPERO; // Variable que indica el estado en el que se encuentra la maquina de estados
+int hab_maq_VTilt = DESHABILITADO;  // Habilitacion de dicha maquina de estados
+int timeout_VTilt = DESHABILITADO;  // Variable que que se habilitará cuando el tiempo establecido en el Timeout se cumpla ( usada para cambiar de estado)
+int direccion_VTilt = DERECHA; // Variable que voy a usar para indicar la direccion que tendrá el giro del motor
+int velocidad_VTilt = 1;   // Variable que voy a usar para indicar la velocidad a la que quiero que se mueva el motor
+volatile int incremento_VTilt = DESHABILITADO;// Variable que voy a usar para realizar los pasos siempre cada el mismo tiempo, y no  cada vez mas rapido.
+int stop_VTilt = MOVIENDO;   // Variable que me indicará si el motor se esta moviendo o esta quieto, para poder cambiar de modo SOLO cuando se encuente quieto
+int intensidad_VTilt = 10; // Variable que indica el que tan rapido es el multiplicador de la velocidad del joystick ( Varia de 1 (lento) a 10 (rapido))
+
+// -------------- Manejo Pan
+
+DigitalOut Pan_dir(PTC6);
+DigitalOut Pan_step(PTC5);
+
+DigitalIn opto_pan(PTC1);
+
+void MAQ_VPan(int velocidad_deseada, int direccion);    //Maquina de estados que controlará el motor de slide por Velocidad ( usada por los joysticks )
+void timeoutVPan();    // Funcion que será llamada por el Timeout que use para realizar los pasos del motor de slide
+void paso_VPan();     // Funcion que será llamada por un ticker para que todos los pasos se realicen cada el mismo tiempo, y no dependiendo de la velocidad
+
+Ticker ticker_VPan;   // Ticker que llamará la funcion paso_VSlide() cada 10ms
+Timeout VPan;     // Timeout que usaré para cambiar de estado en la maquina de control por velocidad
+
+int estado_VPan = ESPERO; // Variable que indica el estado en el que se encuentra la maquina de estados
+int hab_maq_VPan = DESHABILITADO;  // Habilitacion de dicha maquina de estados
+int timeout_VPan = DESHABILITADO;  // Variable que que se habilitará cuando el tiempo establecido en el Timeout se cumpla ( usada para cambiar de estado)
+int direccion_VPan = DERECHA; // Variable que voy a usar para indicar la direccion que tendrá el giro del motor
+int velocidad_VPan = 1;   // Variable que voy a usar para indicar la velocidad a la que quiero que se mueva el motor
+volatile int incremento_VPan = DESHABILITADO;// Variable que voy a usar para realizar los pasos siempre cada el mismo tiempo, y no  cada vez mas rapido.
+int stop_VPan = MOVIENDO;   // Variable que me indicará si el motor se esta moviendo o esta quieto, para poder cambiar de modo SOLO cuando se encuente quieto
+int intensidad_VPan = 10; // Variable que indica el que tan rapido es el multiplicador de la velocidad del joystick ( Varia de 1 (lento) a 10 (rapido))
+
+// -------------- Modo joystick
+
+RawSerial control(PTA2, PTA1);  // Puerto serie para recibir datos del control, no se utiliza el Tx
+RawSerial app(PTE0, PTE1);    // Puerto serie para recibir Y enviar datos a la aplicacion via bluetooth
+
+int joystick_VSlide = 120;  // Variable que guarda el valor del joystick recibido por el HC-11
+int app_VSlide = 120;       // Variable que guarda el valor del joystick recibido por la aplicacion via bluetooth
+
+int joystick_VTilt = 120;  // Variable que guarda el valor del joystick recibido por el HC-11
+int app_VTilt = 120;       // Variable que guarda el valor del joystick recibido por la aplicacion via bluetooth
+
+int joystick_VPan = 120;  // Variable que guarda el valor del joystick recibido por el HC-11
+int app_VPan = 120;       // Variable que guarda el valor del joystick recibido por la aplicacion via bluetooth
+
+int pasos_slide = 0;
+int pasos_tilt = 0;
+int pasos_pan = 0;
+
+void control_joystick();
+void control_app();
+
+void MAQ_recepcion_control();
+void MAQ_recepcion_app();
+
+void interrupcion_control();
+void interrupcion_app();
+
+volatile char ingreso_control; // En la variable 'ingreso_control' e 'ingreso_app' el valor 0 representa que no se ingresó nada
+volatile char ingreso_app;  // En la variable 'ingreso_control' e 'ingreso_app' el valor 0 representa que no se ingresó nada
+
+int estado_recepcion_app = START;
+int estado_recepcion_control = START;
+
+int modo_de_funcionamiento = APP;
+int modo_de_funcionamiento_actual = APP;
+
+PinName const SDA = PTE25;
+PinName const SCL = PTE24;
+
+MMA8451Q acc(SDA, SCL, MMA8451_I2C_ADDRESS);
+void acelerometro();
+Ticker giroscopo;
+
+
+enum {NUNCA, SEGUNDOS, MINUTOS, HORAS};
+int loop = DESHABILITADO;
+int loopRetraso = 0;
+int loopRetrasoUnidadDeTiempo = SEGUNDOS;
+int loopDetenerseUnidadDeTiempo = SEGUNDOS;
+int loopDetenerse = NUNCA;
+void control_loop();
+Timeout desactivar_loop;
+Timeout retraso_loop;
+
+void off_loop();
+void MAQ_loop();
+int estado_maq_loop = ESPERO;
+int flag_delay_loop = DESHABILITADO;
+void delay_loop()
+{
+    flag_delay_loop = HABILITADO;
+}
+void secuencia_inicio();
+
+int punto_especifico = DESHABILITADO;
+int posicion_slide = 0;
+int posicion_pan = 0;
+void control_pe();
+
+int tiempoTimelapse = 0;
+int unidadtiempoTimelapse = 0;
+int lado_Timelapse = 0;
+int modo_Timelapse = 0;
+int stateTimelapse = DESHABILITADO;
+int flag_timelapse = 0;
+void inicio_timelapse();
+
+int main()
+{
+
+    control.baud(115200);
+    control.attach(&interrupcion_control, Serial::RxIrq);
+    app.baud(115200);
+    app.attach(&interrupcion_app, Serial::RxIrq);
+
+    ticker_VSlide.attach_us(&paso_VSlide,10000);
+    ticker_VTilt.attach_us(&paso_VTilt,1000);
+    ticker_VPan.attach_us(&paso_VPan,1000);
+    giroscopo.attach(&acelerometro,0.65);
+    fc1.mode(PullUp);
+    fc2.mode(PullUp);
+
+    secuencia_inicio();
+
+
+    while(1) {
+        // SIEMPRE leo los datos que me llegan de la APP
+        if(ingreso_control != NADA) { // Cuando recibo algo en el puerto serie, lo leo.
+            MAQ_recepcion_control();
+            ingreso_control = NADA;
+        }
+        // SIEMPRE leo los datos que me llegan del control remoto, siempre y cuando esté prendido
+        if(ingreso_app != NADA) { // Cuando recibo algo en el puerto serie, lo leo.
+            MAQ_recepcion_app();
+            ingreso_app = NADA;
+        }
+        if(modo_de_funcionamiento_actual != modo_de_funcionamiento) { // Si recibo orden para cambiar de modo, llevo el slide a un "modo seguro" de stop
+            hab_maq_VSlide = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VSlide = 0; // Seteo la velocidad en 0
+            hab_maq_VTilt = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VTilt = 0; // Seteo la velocidad en 0
+            hab_maq_VPan = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VPan = 0; // Seteo la velocidad en 0
+            MAQ_VSlide(velocidad_VSlide,direccion_VSlide);
+            MAQ_VTilt(velocidad_VTilt*0.1,direccion_VTilt);
+            MAQ_VPan(velocidad_VPan*0.1,direccion_VPan);
+            if((stop_VSlide == QUIETO)&&(stop_VTilt == QUIETO)&&(stop_VPan == QUIETO)) {
+                // Reseteo la variable que indica el modo a un estado false.
+                // Cambio la variable del switch de modo
+                modo_de_funcionamiento_actual = modo_de_funcionamiento;
+            }
+        } else if(modo_de_funcionamiento_actual == modo_de_funcionamiento) { // Si no se tiene que cambiar de modo, sigo interpretando los datos recibidos
+            switch(modo_de_funcionamiento) { // Vario la interpretacion de datos dependiendo lo que se elija en la app
+                // Le envio a la app que modo hay actualmente
+                case APP: // Caso: Controlado por APP
+                    if(loop == HABILITADO) {
+                        switch(punto_especifico) {
+                            case HABILITADO:
+                                control_pe();
+                                break;
+                            case DESHABILITADO:
+                                control_loop();
+                                break;
+                        }
+
+                        MAQ_loop();
+                        MAQ_VTilt(velocidad_VTilt*0.1,direccion_VTilt);
+                        MAQ_VPan(velocidad_VPan*0.1,direccion_VPan);
+                        MAQ_VSlide(velocidad_VSlide,direccion_VSlide);
+                    } else {
+                        if(stateTimelapse == DESHABILITADO) {
+                            flag_timelapse = 0;
+                            control_app();
+                            MAQ_VSlide(velocidad_VSlide,direccion_VSlide);
+                            MAQ_VTilt(velocidad_VTilt*0.1,direccion_VTilt);
+                            MAQ_VPan(velocidad_VPan*0.1,direccion_VPan);
+                        } else {
+                            if(flag_timelapse == 0){
+                                flag_timelapse = 1;
+                                inicio_timelapse();
+                                
+                            }
+                            
+                            
+                        }
+                    }
+
+                    break;
+                case CONTROL: // Caso: Controlado por Control remoto
+                    control_joystick();
+                    MAQ_VSlide(velocidad_VSlide,direccion_VSlide);
+                    MAQ_VTilt(velocidad_VTilt*0.1,direccion_VTilt);
+                    MAQ_VPan(velocidad_VPan*0.1,direccion_VPan);
+                    break;
+            }
+        }
+    }
+}
+void inicio_timelapse()
+{
+    switch(lado_Timelapse) {
+        case IZQUIERDA:
+            for(; (pasos_slide > ((MAX_SLIDE * 1)/40));) {
+                MAQ_VSlide(1000,DERECHA);
+            }
+            break;
+        case DERECHA:
+            for(; (pasos_slide < ((MAX_SLIDE * 39)/40));) {
+                MAQ_VSlide(1000,IZQUIERDA);
+            }
+            break;
+    }
+}
+void control_pe()
+{
+    hab_maq_VPan = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+    if(pasos_slide > posicion_slide) {
+        if((direccion_VPan == IZQUIERDA)&&(pasos_tilt < ((MAX_TILT * 39)/40))) {
+            direccion_VPan = IZQUIERDA; // Establezco la direccion correspondiente del giro del motor
+            velocidad_VPan = 500 * (pasos_pan * 100)/(MAX_PAN / 2) * (pasos_slide * 100)/(MAX_SLIDE / 2);   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            direccion_VPan = DERECHA;
+        }
+    } else {
+        if((direccion_VPan == DERECHA)&&(pasos_tilt > ((MAX_TILT * 1)/ 40))) {
+            direccion_VPan = DERECHA; // Establezco la direccion correspondiente del giro del motor
+            velocidad_VPan = 500 * (pasos_pan * 100)/(MAX_PAN / 2) * (pasos_slide * 100)/(MAX_SLIDE / 2);   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            direccion_VPan = IZQUIERDA;
+        }
+    }
+}
+
+void off_loop()
+{
+    loop = DESHABILITADO;
+    app.putc('$');
+    app.putc('L');
+    app.putc('0');
+    app.putc('e');
+    app.putc('!');
+}
+void MAQ_loop()
+{
+    static int prox_dir = DERECHA;
+    switch(estado_maq_loop) {
+        case ESPERO:
+
+            estado_maq_loop = RIGHT;
+
+            break;
+        case RIGHT:
+
+            if(pasos_slide < ((MAX_SLIDE * 39)/40)) {
+                hab_maq_VSlide = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+                direccion_VSlide = DERECHA; // Establezco la direccion correspondiente del giro del motor
+                velocidad_VSlide = intensidad_VSlide * 100;   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+            } else {
+                velocidad_VSlide = 0;
+                direccion_VSlide = DERECHA;
+                hab_maq_VTilt = DESHABILITADO;     // Deshabilito la maquina
+                if(stop_VSlide == QUIETO) {
+                    estado_maq_loop = HOLD;
+                    switch(loopRetrasoUnidadDeTiempo) {
+                        case SEGUNDOS:
+                            retraso_loop.attach(&delay_loop,loopRetraso);
+                            break;
+                        case MINUTOS:
+                            retraso_loop.attach(&delay_loop,loopRetraso*60);
+                            break;
+                        case HORAS:
+                            retraso_loop.attach(&delay_loop,loopRetraso * 60); // Falta multiplicar por 60 mas
+                            break;
+
+                    }
+                    prox_dir = IZQUIERDA;
+                }
+            }
+            break;
+        case HOLD:
+            if(flag_delay_loop == HABILITADO) {
+                flag_delay_loop = DESHABILITADO;
+                switch(prox_dir) {
+                    case DERECHA:
+                        estado_maq_loop = RIGHT;
+                        break;
+                    case IZQUIERDA:
+                        estado_maq_loop = LEFT;
+                        break;
+                }
+            }
+            break;
+        case LEFT:
+            if(pasos_slide > ((MAX_SLIDE * 1)/ 40)) {
+                hab_maq_VSlide = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+                direccion_VSlide = IZQUIERDA; // Establezco la direccion correspondiente del giro del motor
+                velocidad_VSlide = intensidad_VSlide * 100;   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+            } else {
+                velocidad_VSlide = 0;
+                direccion_VSlide = IZQUIERDA;
+                hab_maq_VTilt = DESHABILITADO;     // habilito la maquina
+                if(stop_VSlide == QUIETO) {
+                    estado_maq_loop = HOLD;
+                    switch(loopRetrasoUnidadDeTiempo) {
+                        case SEGUNDOS:
+                            retraso_loop.attach(&delay_loop,loopRetraso);
+                            break;
+                        case MINUTOS:
+                            retraso_loop.attach(&delay_loop,loopRetraso*60);
+                            break;
+                        case HORAS:
+                            retraso_loop.attach(&delay_loop,loopRetraso * 60); // Falta multiplicar por 60 mas
+                            break;
+                    }
+                    prox_dir = DERECHA;
+                }
+            }
+            break;
+
+    }
+
+}
+void secuencia_inicio()
+{
+    int hab_slide = 1;
+    int hab_pan = 1;
+    int hab_tilt = 1;
+    hab_maq_VSlide = 1;
+    hab_maq_VTilt = 1;
+    hab_maq_VPan = 1;
+    while(1) {
+
+        if((fc1 == 0)||(fc2 == 0)) {
+            hab_slide = 0;
+        } else {
+            if(hab_slide == 1) {
+                MAQ_VSlide(1000,1);
+            }
+        }
+        if(opto_tilt != 1) {
+            if(hab_tilt == 1) {
+                MAQ_VTilt(100,1);
+            }
+        } else {
+            hab_tilt = 0;
+        }
+        if(opto_pan != 1) {
+            if(hab_pan == 1) {
+                MAQ_VPan(100,1);
+            }
+        } else {
+            hab_pan = 0;
+        }
+        if((hab_slide == 0)&&(hab_tilt == 0)&&(hab_pan == 0)) {
+            break;
+        }
+    }
+    estado_VSlide = ESPERO; // Vuelvo al estado de reset
+    estado_VTilt = ESPERO; // Vuelvo al estado de reset
+    estado_VPan = ESPERO; // Vuelvo al estado de reset
+
+    hab_slide = 1;
+    hab_tilt = 1;
+    hab_pan = 1;
+
+    pasos_slide = 0;
+    pasos_tilt = 0;
+    pasos_pan = 0;
+
+    while(1) {
+        if(pasos_slide < (MAX_SLIDE / 2)) {
+            MAQ_VSlide(1000,0);
+        } else {
+            hab_slide = 0;
+        }
+        if(pasos_tilt < (MAX_TILT / 2)) {
+            MAQ_VTilt(100,0);
+        } else {
+            hab_tilt = 0;
+        }
+        if(pasos_pan < (MAX_PAN / 2)) {
+            MAQ_VPan(100,0);
+        } else {
+            hab_pan = 0;
+        }
+        if((hab_slide == 0)&&(hab_tilt == 0)&&(hab_pan == 0)) {
+            break;
+        }
+
+    }
+    app.putc('a');
+
+}
+void interrupcion_control()
+{
+    ingreso_control = control.getc();
+}
+void interrupcion_app()
+{
+    ingreso_app = app.getc();
+}
+void acelerometro()
+{
+    float x, grados;
+    int d,u;
+    x = abs(acc.getAccX());
+    grados = x * 90;
+    app.putc('$');
+    app.putc('I');
+    app.putc('S');
+    d = grados / 10;
+    u = grados - d * 10;
+    app.putc(0 + 0x30);
+    app.putc(d + 0x30);
+    app.putc(u + 0x30);
+    app.putc('e');
+    app.putc('!');
+
+}
+void control_joystick()
+{
+    if((joystick_VSlide >= 0)&&(joystick_VSlide <= 112)) {    // Rango del joystick que se mueve hacia una direccion
+
+        hab_maq_VSlide = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+        direccion_VSlide = DERECHA; // Establezco la direccion correspondiente del giro del motor
+        velocidad_VSlide = intensidad_VSlide * (109 - joystick_VSlide);   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+    }
+    if((joystick_VSlide >= 115)&&(joystick_VSlide <= 140)) {  // Rango del joystick donde se encuentra estable el motor
+        hab_maq_VSlide = DESHABILITADO;     // Deshabilito la maquina
+        velocidad_VSlide = 0; // Seteo la velocidad en 0
+    }
+    if((joystick_VSlide >= 145)&&(joystick_VSlide <= 255)) {  // Rango del joystick que se mueve hacia la otra direccion
+        hab_maq_VSlide = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+        direccion_VSlide = IZQUIERDA;   // Establezco la direccion correspondiente del giro del motor
+        velocidad_VSlide = intensidad_VSlide * (joystick_VSlide - 149);    // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+    }
+    if((joystick_VTilt >= 0)&&(joystick_VTilt <= 112)) {    // Rango del joystick que se mueve hacia una direccion
+
+        hab_maq_VTilt = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+        direccion_VTilt = DERECHA; // Establezco la direccion correspondiente del giro del motor
+        velocidad_VTilt = intensidad_VTilt * (109 - joystick_VTilt);   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+    }
+    if((joystick_VTilt >= 115)&&(joystick_VTilt <= 140)) {  // Rango del joystick donde se encuentra estable el motor
+        hab_maq_VTilt = DESHABILITADO;     // Deshabilito la maquina
+        velocidad_VTilt = 0; // Seteo la velocidad en 0
+    }
+    if((joystick_VTilt >= 145)&&(joystick_VTilt <= 255)) {  // Rango del joystick que se mueve hacia la otra direccion
+        hab_maq_VTilt = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+        direccion_VTilt = IZQUIERDA;   // Establezco la direccion correspondiente del giro del motor
+        velocidad_VTilt = intensidad_VTilt * (joystick_VTilt - 149);    // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+    }
+    if((joystick_VPan >= 0)&&(joystick_VPan <= 112)) {    // Rango del joystick que se mueve hacia una direccion
+
+        hab_maq_VPan = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+        direccion_VPan = DERECHA; // Establezco la direccion correspondiente del giro del motor
+        velocidad_VPan = intensidad_VPan * (109 - joystick_VPan);   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+    }
+    if((joystick_VPan >= 115)&&(joystick_VPan <= 140)) {  // Rango del joystick donde se encuentra estable el motor
+        hab_maq_VPan = DESHABILITADO;     // Deshabilito la maquina
+        velocidad_VPan = 0; // Seteo la velocidad en 0
+    }
+    if((joystick_VPan >= 145)&&(joystick_VPan <= 255)) {  // Rango del joystick que se mueve hacia la otra direccion
+        hab_maq_VPan = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+        direccion_VPan = IZQUIERDA;   // Establezco la direccion correspondiente del giro del motor
+        velocidad_VPan = intensidad_VPan * (joystick_VPan - 149);    // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+    }
+
+}
+void control_loop()
+{
+    if((app_VTilt >= 0)&&(app_VTilt <= 112)) {    // Rango del joystick que se mueve hacia una direccion
+        if(pasos_tilt < ((MAX_TILT * 39)/40)) {
+            hab_maq_VTilt = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+            direccion_VTilt = DERECHA; // Establezco la direccion correspondiente del giro del motor
+            velocidad_VTilt = intensidad_VTilt * (109 - app_VTilt);   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            hab_maq_VTilt = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VTilt = 0; // Seteo la velocidad en 0
+        }
+    }
+    if((app_VTilt >= 115)&&(app_VTilt <= 140)) {  // Rango del joystick donde se encuentra estable el motor
+        hab_maq_VTilt = DESHABILITADO;     // Deshabilito la maquina
+        velocidad_VTilt = 0; // Seteo la velocidad en 0
+    }
+    if((app_VTilt >= 145)&&(app_VTilt <= 255)) {  // Rango del joystick que se mueve hacia la otra direccion
+        if(pasos_tilt > ((MAX_TILT * 1)/ 40)) {
+            hab_maq_VTilt = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+            direccion_VTilt = IZQUIERDA;   // Establezco la direccion correspondiente del giro del motor
+            velocidad_VTilt = intensidad_VTilt * (app_VTilt - 149);    // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            hab_maq_VTilt = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VTilt = 0; // Seteo la velocidad en 0
+        }
+    }
+    //--
+    if((app_VPan >= 0)&&(app_VPan <= 112)) {    // Rango del joystick que se mueve hacia una direccion
+        if(pasos_pan < ((MAX_PAN * 39)/40)) {
+            hab_maq_VPan = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+            direccion_VPan = DERECHA; // Establezco la direccion correspondiente del giro del motor
+            velocidad_VPan = intensidad_VPan * (109 - app_VPan);   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            hab_maq_VPan = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VPan = 0; // Seteo la velocidad en 0
+        }
+    }
+    if((app_VPan >= 115)&&(app_VPan <= 140)) {  // Rango del joystick donde se encuentra estable el motor
+        hab_maq_VPan = DESHABILITADO;     // Deshabilito la maquina
+        velocidad_VPan = 0; // Seteo la velocidad en 0
+    }
+    if((app_VPan >= 145)&&(app_VPan <= 255)) {  // Rango del joystick que se mueve hacia la otra direccion
+        if(pasos_pan > ((MAX_PAN * 1)/ 40)) {
+            hab_maq_VPan = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+            direccion_VPan = IZQUIERDA;   // Establezco la direccion correspondiente del giro del motor
+            velocidad_VPan = intensidad_VPan * (app_VPan - 149);    // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            hab_maq_VPan = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VPan = 0; // Seteo la velocidad en 0
+        }
+    }
+}
+void control_app()
+{
+    if((app_VSlide >= 0)&&(app_VSlide <= 112)) {    // Rango del joystick que se mueve hacia una direccion
+        if(pasos_slide < ((MAX_SLIDE * 39)/40)) {
+            hab_maq_VSlide = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+            direccion_VSlide = DERECHA; // Establezco la direccion correspondiente del giro del motor
+            velocidad_VSlide = intensidad_VSlide * (109 - app_VSlide);   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            hab_maq_VSlide = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VSlide = 0; // Seteo la velocidad en 0
+        }
+    }
+    if((app_VSlide >= 115)&&(app_VSlide <= 140)) {  // Rango del joystick donde se encuentra estable el motor
+        hab_maq_VSlide = DESHABILITADO;     // Deshabilito la maquina
+        velocidad_VSlide = 0; // Seteo la velocidad en 0
+    }
+    if((app_VSlide >= 145)&&(app_VSlide <= 255)) {  // Rango del joystick que se mueve hacia la otra direccion
+        if(pasos_slide > ((MAX_SLIDE * 1)/ 40)) {
+            hab_maq_VSlide = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+            direccion_VSlide = IZQUIERDA;   // Establezco la direccion correspondiente del giro del motor
+            velocidad_VSlide = intensidad_VSlide * (app_VSlide - 149);    // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            hab_maq_VSlide = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VSlide = 0; // Seteo la velocidad en 0
+        }
+    }
+    //--
+    if((app_VTilt >= 0)&&(app_VTilt <= 112)) {    // Rango del joystick que se mueve hacia una direccion
+        if(pasos_tilt < ((MAX_TILT * 39)/40)) {
+            hab_maq_VTilt = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+            direccion_VTilt = DERECHA; // Establezco la direccion correspondiente del giro del motor
+            velocidad_VTilt = intensidad_VTilt * (109 - app_VTilt);   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            hab_maq_VTilt = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VTilt = 0; // Seteo la velocidad en 0
+        }
+    }
+    if((app_VTilt >= 115)&&(app_VTilt <= 140)) {  // Rango del joystick donde se encuentra estable el motor
+        hab_maq_VTilt = DESHABILITADO;     // Deshabilito la maquina
+        velocidad_VTilt = 0; // Seteo la velocidad en 0
+    }
+    if((app_VTilt >= 145)&&(app_VTilt <= 255)) {  // Rango del joystick que se mueve hacia la otra direccion
+        if(pasos_tilt > ((MAX_TILT * 1)/ 40)) {
+            hab_maq_VTilt = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+            direccion_VTilt = IZQUIERDA;   // Establezco la direccion correspondiente del giro del motor
+            velocidad_VTilt = intensidad_VTilt * (app_VTilt - 149);    // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            hab_maq_VTilt = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VTilt = 0; // Seteo la velocidad en 0
+        }
+    }
+    //--
+    if((app_VPan >= 0)&&(app_VPan <= 112)) {    // Rango del joystick que se mueve hacia una direccion
+        if(pasos_pan < ((MAX_PAN * 39)/40)) {
+            hab_maq_VPan = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+            direccion_VPan = DERECHA; // Establezco la direccion correspondiente del giro del motor
+            velocidad_VPan = intensidad_VPan * (109 - app_VPan);   // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            hab_maq_VPan = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VPan = 0; // Seteo la velocidad en 0
+        }
+    }
+    if((app_VPan >= 115)&&(app_VPan <= 140)) {  // Rango del joystick donde se encuentra estable el motor
+        hab_maq_VPan = DESHABILITADO;     // Deshabilito la maquina
+        velocidad_VPan = 0; // Seteo la velocidad en 0
+    }
+    if((app_VPan >= 145)&&(app_VPan <= 255)) {  // Rango del joystick que se mueve hacia la otra direccion
+        if(pasos_pan > ((MAX_PAN * 1)/ 15)) {
+            hab_maq_VPan = HABILITADO;    // Habilito la maquina de estados de manejo por velocidad
+            direccion_VPan = IZQUIERDA;   // Establezco la direccion correspondiente del giro del motor
+            velocidad_VPan = intensidad_VPan * (app_VPan - 149);    // Seteo la velocidad, dependiendo del nivel ( de 0 a 10 ) y del valor analogico del joystick
+        } else {
+            hab_maq_VPan = DESHABILITADO;     // Deshabilito la maquina
+            velocidad_VPan = 0; // Seteo la velocidad en 0
+        }
+    }
+}
+void timeoutVSlide()
+{
+    timeout_VSlide = HABILITADO;    // Aviso que pasó el tiempo que se estableció
+}
+void paso_VSlide()
+{
+    incremento_VSlide = HABILITADO; // Aviso que se puede incrementar la velocidad del motor
+}
+void timeoutVTilt()
+{
+    timeout_VTilt = HABILITADO;    // Aviso que pasó el tiempo que se estableció
+}
+void paso_VTilt()
+{
+    incremento_VTilt = HABILITADO; // Aviso que se puede incrementar la velocidad del motor
+}
+void timeoutVPan()
+{
+    timeout_VPan = HABILITADO;    // Aviso que pasó el tiempo que se estableció
+}
+void paso_VPan()
+{
+    incremento_VPan = HABILITADO; // Aviso que se puede incrementar la velocidad del motor
+}
+void MAQ_VSlide(int velocidad_deseada, int direccion)
+{
+    // Para que no existan cambios bruscos de velocidad, voy a ir incrementando el valor actual de la misma hasta llegar al punto que deseo.
+    // De esta forma, seteo dos variables para poder lograr ese efecto.
+    // Además, yo voy a querer que el motor no se detenga de golpe, asi que aprovecho este ultimo metodo para realizar esa operacion.
+
+    static int ticker_actual = 0;   // Variable que me indicará el valor actual de tiempo de ticker (en micro-segundos)
+    static int ticker_deseado = 0;  // Variable que me indicará el valor deseado de tiempo de ticker (en micro-segundos), depèndiendo del joystick y de la pausa que se desee lograr
+
+    switch(estado_VSlide) {
+
+        case ESPERO:    // Caso: Espero habilitacion de la maquina.
+
+            stop_VSlide = QUIETO;   // Indico que la maquina no se activo todavia
+
+            if(hab_maq_VSlide == HABILITADO) {
+
+                Slide_dir = direccion;  // Establezco la salida fisica igual a la direccion que se indicó en la función
+
+                ticker_actual = 1999;   // Seteo la velocidad de inicio como una lo suficientemente lenta como para considerar el motor "parado"
+
+                ticker_deseado = (1100 - velocidad_deseada);    // Seteo el tiempo del ticker deseado, dependiendo del valor de velocidad que se haya ingresado en la funcion.
+
+                timeout_VSlide = DESHABILITADO; // Reseteo el Flag del timeout
+
+                VSlide.attach_us(&timeoutVSlide, ticker_actual);    // Seteo el tiempo para con el que se realizarán los cambios de estado
+
+                estado_VSlide = PASO;   // Cambio de estado
+
+                stop_VSlide = MOVIENDO; // Indico que el motor se esta moviendo
+            }
+            break;
+
+        case PASO:  // Caso: pongo la salida de step en 1
+
+            Slide_step = 1;   // Pongo la salida de step en 1
+
+            if(timeout_VSlide == HABILITADO) {  // Transicion a otro estado: cuando pasó el tiempo establecido en el ticker
+
+                timeout_VSlide = DESHABILITADO; // Reseteo el Flag del timeout
+
+                if(velocidad_deseada != 0) {    // Siempre que la velocidad sea distinta de 0, es decir, que el joystick no esté en el estado de reposo
+
+                    ticker_deseado = (1100 - velocidad_deseada);    // Seteo el tiempo del ticker deseado, dependiendo del valor de velocidad que se haya ingresado en la funcion.
+
+                } else {
+                    ticker_deseado = 2000;  // Si se desea el motor, establezco el ticker a un tiempo que sea tan lento como para considerar el motor parado
+                }
+
+                if(Slide_dir != direccion) {  // Caso de que la direccion deseada no sea la direccion ACTUAL del motor
+                    // En este caso, primero debo detener el motor para poder así comenzar otra vez con el giro
+
+                    if(incremento_VSlide == HABILITADO) {   // Si pasó el tiempo suficiente como para poder incrementar o disminuir la velocidad:
+                        incremento_VSlide = DESHABILITADO;  // Limpio el Flag
+                        ticker_actual = ticker_actual + 10; // Incremento el ticker. Esto hará que cada vez el motor gire mas lento
+                    }
+                    if(ticker_actual >= 2000) { // Cuando considero que el motor está casi detenido:
+                        Slide_dir = direccion;    // Cambio la direccion
+                    }
+                } else if(Slide_dir == direccion) {   // Caso de que la direccion sea la misma que la deseada:
+                    // En este caso, voy a aumentar o disminuir la velocidad dependiendo de lo que se desee
+
+                    if(ticker_actual > ticker_deseado) {    // Si el motor esta yendo mas lento que lo que yo deseo:
+                        if(incremento_VSlide == HABILITADO) { // Y me encuentro habilitado para incrementar:
+                            incremento_VSlide = DESHABILITADO;    // Limpio el Flag
+                            ticker_actual = ticker_actual - 10; // Y aumento la velocidad
+                        }
+                    }
+                    if(ticker_actual < ticker_deseado) {    // Si el motor esta yendo mas rapido de lo que debería:
+                        if(incremento_VSlide == HABILITADO) { // Y me encuentro habilitado para incrementar:
+                            incremento_VSlide = DESHABILITADO;    // Limpio el Flag
+                            ticker_actual = ticker_actual + 10; // Y disminuyo la velocidad
+                        }
+                    }
+                }
+                VSlide.attach_us(&timeoutVSlide, ticker_actual);    // Seteo el tiempo para con el que se realizarán los cambios de estado
+                estado_VSlide = DELAY;  // Cambio de estado
+            }
+            break;
+
+        case DELAY: // Caso: pongo la salida de step en 0
+            Slide_step = 0;   // Pongo la salida de step en 0
+
+            if(timeout_VSlide == HABILITADO) {  // Transicion a otro estado: cuando pasó el tiempo establecido en el ticker
+                timeout_VSlide = DESHABILITADO; // Limpio Flag
+
+                if(ticker_actual >= 2000) { // Si la velocidad del motor es mas lenta de lo que yo considero como parado:
+
+                    estado_VSlide = ESPERO; // Vuelvo al estado de reset
+                    hab_maq_VSlide = DESHABILITADO;     // Deshabilito la maquina
+
+                } else {    // Si el motor "sigue moviendose":
+                    VSlide.attach_us(&timeoutVSlide, ticker_actual);    // Vuelvo a establecer un tiempo para cambiar de estado
+                    if(Slide_dir == 1) {
+                        pasos_slide--;  // Como hice un paso, lo sumo a la cuenta.
+                    } else {
+                        pasos_slide++;  // Como hice un paso, lo sumo a la cuenta.
+                    }
+
+                    estado_VSlide = PASO;   // Cambio de estado
+                }
+            }
+            break;
+    }
+}
+void MAQ_VTilt(int velocidad_deseada, int direccion)
+{
+    // Para que no existan cambios bruscos de velocidad, voy a ir incrementando el valor actual de la misma hasta llegar al punto que deseo.
+    // De esta forma, seteo dos variables para poder lograr ese efecto.
+    // Además, yo voy a querer que el motor no se detenga de golpe, asi que aprovecho este ultimo metodo para realizar esa operacion.
+
+    static int ticker_actual = 0;   // Variable que me indicará el valor actual de tiempo de ticker (en micro-segundos)
+    static int ticker_deseado = 0;  // Variable que me indicará el valor deseado de tiempo de ticker (en micro-segundos), depèndiendo del joystick y de la pausa que se desee lograr
+
+    switch(estado_VTilt) {
+
+        case ESPERO:    // Caso: Espero habilitacion de la maquina.
+
+            stop_VTilt = QUIETO;   // Indico que la maquina no se activo todavia
+
+            if(hab_maq_VTilt == HABILITADO) {
+
+                Tilt_dir = direccion;  // Establezco la salida fisica igual a la direccion que se indicó en la función
+
+                ticker_actual = 1999;   // Seteo la velocidad de inicio como una lo suficientemente lenta como para considerar el motor "parado"
+
+                ticker_deseado = (1300 - velocidad_deseada);    // Seteo el tiempo del ticker deseado, dependiendo del valor de velocidad que se haya ingresado en la funcion.
+
+                timeout_VTilt = DESHABILITADO; // Reseteo el Flag del timeout
+
+                VTilt.attach_us(&timeoutVTilt, ticker_actual);    // Seteo el tiempo para con el que se realizarán los cambios de estado
+
+                estado_VTilt = PASO;   // Cambio de estado
+
+                stop_VTilt = MOVIENDO; // Indico que el motor se esta moviendo
+            }
+            break;
+
+        case PASO:  // Caso: pongo la salida de step en 1
+
+            Tilt_step = 1;   // Pongo la salida de step en 1
+
+            if(timeout_VTilt == HABILITADO) {  // Transicion a otro estado: cuando pasó el tiempo establecido en el ticker
+
+                timeout_VTilt = DESHABILITADO; // Reseteo el Flag del timeout
+
+                if(velocidad_deseada != 0) {    // Siempre que la velocidad sea distinta de 0, es decir, que el joystick no esté en el estado de reposo
+
+                    ticker_deseado = (1300 - velocidad_deseada);    // Seteo el tiempo del ticker deseado, dependiendo del valor de velocidad que se haya ingresado en la funcion.
+
+                } else {
+                    ticker_deseado = 2000;  // Si se desea el motor, establezco el ticker a un tiempo que sea tan lento como para considerar el motor parado
+                }
+
+                if(Tilt_dir != direccion) {  // Caso de que la direccion deseada no sea la direccion ACTUAL del motor
+                    // En este caso, primero debo detener el motor para poder así comenzar otra vez con el giro
+
+                    if(incremento_VTilt == HABILITADO) {   // Si pasó el tiempo suficiente como para poder incrementar o disminuir la velocidad:
+                        incremento_VTilt = DESHABILITADO;  // Limpio el Flag
+                        ticker_actual = ticker_actual + 10; // Incremento el ticker. Esto hará que cada vez el motor gire mas lento
+                    }
+                    if(ticker_actual >= 2000) { // Cuando considero que el motor está casi detenido:
+                        Tilt_dir = direccion;    // Cambio la direccion
+                    }
+                } else if(Tilt_dir == direccion) {   // Caso de que la direccion sea la misma que la deseada:
+                    // En este caso, voy a aumentar o disminuir la velocidad dependiendo de lo que se desee
+
+                    if(ticker_actual > ticker_deseado) {    // Si el motor esta yendo mas lento que lo que yo deseo:
+                        if(incremento_VTilt == HABILITADO) { // Y me encuentro habilitado para incrementar:
+                            incremento_VTilt = DESHABILITADO;    // Limpio el Flag
+                            ticker_actual = ticker_actual - 10; // Y aumento la velocidad
+                        }
+                    }
+                    if(ticker_actual < ticker_deseado) {    // Si el motor esta yendo mas rapido de lo que debería:
+                        if(incremento_VTilt == HABILITADO) { // Y me encuentro habilitado para incrementar:
+                            incremento_VTilt = DESHABILITADO;    // Limpio el Flag
+                            ticker_actual = ticker_actual + 10; // Y disminuyo la velocidad
+                        }
+                    }
+                }
+                VTilt.attach_us(&timeoutVTilt, ticker_actual);    // Seteo el tiempo para con el que se realizarán los cambios de estado
+                estado_VTilt = DELAY;  // Cambio de estado
+            }
+            break;
+
+        case DELAY: // Caso: pongo la salida de step en 0
+            Tilt_step = 0;   // Pongo la salida de step en 0
+
+            if(timeout_VTilt == HABILITADO) {  // Transicion a otro estado: cuando pasó el tiempo establecido en el ticker
+                timeout_VTilt = DESHABILITADO; // Limpio Flag
+
+                if(ticker_actual >= 2000) { // Si la velocidad del motor es mas lenta de lo que yo considero como parado:
+
+                    estado_VTilt = ESPERO; // Vuelvo al estado de reset
+                    hab_maq_VTilt = DESHABILITADO;     // Deshabilito la maquina
+
+                } else {    // Si el motor "sigue moviendose":
+                    VTilt.attach_us(&timeoutVTilt, ticker_actual);    // Vuelvo a establecer un tiempo para cambiar de estado
+                    if(Tilt_dir == 1) {
+                        pasos_tilt--;  // Como hice un paso, lo sumo a la cuenta.
+                    } else {
+                        pasos_tilt++;  // Como hice un paso, lo sumo a la cuenta.
+                    }
+                    estado_VTilt = PASO;   // Cambio de estado
+                }
+            }
+            break;
+    }
+}
+void MAQ_VPan(int velocidad_deseada, int direccion)
+{
+    // Para que no existan cambios bruscos de velocidad, voy a ir incrementando el valor actual de la misma hasta llegar al punto que deseo.
+    // De esta forma, seteo dos variables para poder lograr ese efecto.
+    // Además, yo voy a querer que el motor no se detenga de golpe, asi que aprovecho este ultimo metodo para realizar esa operacion.
+
+    static int ticker_actual = 0;   // Variable que me indicará el valor actual de tiempo de ticker (en micro-segundos)
+    static int ticker_deseado = 0;  // Variable que me indicará el valor deseado de tiempo de ticker (en micro-segundos), depèndiendo del joystick y de la pausa que se desee lograr
+
+    switch(estado_VPan) {
+
+        case ESPERO:    // Caso: Espero habilitacion de la maquina.
+
+            stop_VPan = QUIETO;   // Indico que la maquina no se activo todavia
+
+            if(hab_maq_VPan == HABILITADO) {
+
+                Pan_dir = direccion;  // Establezco la salida fisica igual a la direccion que se indicó en la función
+
+                ticker_actual = 1999;   // Seteo la velocidad de inicio como una lo suficientemente lenta como para considerar el motor "parado"
+
+                ticker_deseado = (1300 - velocidad_deseada);    // Seteo el tiempo del ticker deseado, dependiendo del valor de velocidad que se haya ingresado en la funcion.
+
+                timeout_VPan = DESHABILITADO; // Reseteo el Flag del timeout
+
+                VPan.attach_us(&timeoutVPan, ticker_actual);    // Seteo el tiempo para con el que se realizarán los cambios de estado
+
+                estado_VPan = PASO;   // Cambio de estado
+
+                stop_VPan = MOVIENDO; // Indico que el motor se esta moviendo
+            }
+            break;
+
+        case PASO:  // Caso: pongo la salida de step en 1
+
+            Pan_step = 1;   // Pongo la salida de step en 1
+
+            if(timeout_VPan == HABILITADO) {  // Transicion a otro estado: cuando pasó el tiempo establecido en el ticker
+
+                timeout_VPan = DESHABILITADO; // Reseteo el Flag del timeout
+
+                if(velocidad_deseada != 0) {    // Siempre que la velocidad sea distinta de 0, es decir, que el joystick no esté en el estado de reposo
+
+                    ticker_deseado = (1300 - velocidad_deseada);    // Seteo el tiempo del ticker deseado, dependiendo del valor de velocidad que se haya ingresado en la funcion.
+
+                } else {
+                    ticker_deseado = 2000;  // Si se desea el motor, establezco el ticker a un tiempo que sea tan lento como para considerar el motor parado
+                }
+
+                if(Pan_dir != direccion) {  // Caso de que la direccion deseada no sea la direccion ACTUAL del motor
+                    // En este caso, primero debo detener el motor para poder así comenzar otra vez con el giro
+
+                    if(incremento_VPan == HABILITADO) {   // Si pasó el tiempo suficiente como para poder incrementar o disminuir la velocidad:
+                        incremento_VPan = DESHABILITADO;  // Limpio el Flag
+                        ticker_actual = ticker_actual + 10; // Incremento el ticker. Esto hará que cada vez el motor gire mas lento
+                    }
+                    if(ticker_actual >= 2000) { // Cuando considero que el motor está casi detenido:
+                        Pan_dir = direccion;    // Cambio la direccion
+                    }
+                } else if(Pan_dir == direccion) {   // Caso de que la direccion sea la misma que la deseada:
+                    // En este caso, voy a aumentar o disminuir la velocidad dependiendo de lo que se desee
+
+                    if(ticker_actual > ticker_deseado) {    // Si el motor esta yendo mas lento que lo que yo deseo:
+                        if(incremento_VPan == HABILITADO) { // Y me encuentro habilitado para incrementar:
+                            incremento_VPan = DESHABILITADO;    // Limpio el Flag
+                            ticker_actual = ticker_actual - 10; // Y aumento la velocidad
+                        }
+                    }
+                    if(ticker_actual < ticker_deseado) {    // Si el motor esta yendo mas rapido de lo que debería:
+                        if(incremento_VPan == HABILITADO) { // Y me encuentro habilitado para incrementar:
+                            incremento_VPan = DESHABILITADO;    // Limpio el Flag
+                            ticker_actual = ticker_actual + 10; // Y disminuyo la velocidad
+                        }
+                    }
+                }
+                VPan.attach_us(&timeoutVPan, ticker_actual);    // Seteo el tiempo para con el que se realizarán los cambios de estado
+                estado_VPan = DELAY;  // Cambio de estado
+            }
+            break;
+
+        case DELAY: // Caso: pongo la salida de step en 0
+            Pan_step = 0;   // Pongo la salida de step en 0
+
+            if(timeout_VPan == HABILITADO) {  // Transicion a otro estado: cuando pasó el tiempo establecido en el ticker
+                timeout_VPan = DESHABILITADO; // Limpio Flag
+
+                if(ticker_actual >= 2000) { // Si la velocidad del motor es mas lenta de lo que yo considero como parado:
+
+                    estado_VPan = ESPERO; // Vuelvo al estado de reset
+                    hab_maq_VPan = DESHABILITADO;     // Deshabilito la maquina
+
+                } else {    // Si el motor "sigue moviendose":
+                    VPan.attach_us(&timeoutVPan, ticker_actual);    // Vuelvo a establecer un tiempo para cambiar de estado
+                    if(Pan_dir == 1) {
+                        pasos_pan--;  // Como hice un paso, lo sumo a la cuenta.
+                    } else {
+                        pasos_pan++;  // Como hice un paso, lo sumo a la cuenta.
+                    }
+                    estado_VPan = PASO;   // Cambio de estado
+                }
+            }
+            break;
+    }
+}
+void MAQ_recepcion_app()
+{
+    static int aux_slide[3];
+    static int aux_tilt[3];
+    static int aux_pan[3];
+    static int aux_botones[2];
+    static int crc;
+    static int aux_vel[2];
+    static int trama_recibida = 0;
+    static int aux_modo = 0;
+    static int aux_loop = DESHABILITADO;
+    static int t_delay[4];
+    static int t_out[4];
+    static int aux_pe;
+    static int aux_accuracy[2];
+    static int aux_timelapse;
+    static int timelapse_t[4];
+    static int ladoTimelapse = 0;
+    static int modoTimelapse = 0;
+
+    switch(estado_recepcion_app) {
+        case START:
+
+            // Reseteo todas las variables
+            aux_slide[0] = 0;
+            aux_slide[1] = 0;
+            aux_slide[2] = 0;
+            aux_tilt[0] = 0;
+            aux_tilt[1] = 0;
+            aux_tilt[2] = 0;
+            aux_pan[0] = 0;
+            aux_pan[1] = 0;
+            aux_pan[2] = 0;
+            aux_vel[0] = 0;
+            aux_vel[1] = 0;
+            crc = 0;
+            trama_recibida = 0;
+            aux_modo = 0;
+            aux_loop = DESHABILITADO;
+            t_delay[1]=0;
+            t_delay[2]=0;
+            t_delay[3]=0;
+            t_out[1]=0;
+            t_out[2]=0;
+            t_out[3]=0;
+            aux_accuracy[0] = 0;
+            aux_accuracy[1] = 0;
+            aux_pe = 0;
+            aux_timelapse;
+            timelapse_t[1]=0;
+            timelapse_t[2]=0;
+            timelapse_t[3]=0;
+            ladoTimelapse = 0;
+            modoTimelapse = 0;
+
+
+            if(ingreso_app == '$') {
+                estado_recepcion_app = INICIO;
+            }
+            break;
+
+        case INICIO:
+
+            // Reseteo todas las variables
+            aux_slide[0] = 0;
+            aux_slide[1] = 0;
+            aux_slide[2] = 0;
+            aux_tilt[0] = 0;
+            aux_tilt[1] = 0;
+            aux_tilt[2] = 0;
+            aux_pan[0] = 0;
+            aux_pan[1] = 0;
+            aux_pan[2] = 0;
+            aux_vel[0] = 0;
+            aux_vel[1] = 0;
+            crc = 0;
+            trama_recibida = 0;
+            aux_modo = 0;
+            aux_loop = DESHABILITADO;
+            t_delay[1]=0;
+            t_delay[2]=0;
+            t_delay[3]=0;
+            t_out[1]=0;
+            t_out[2]=0;
+            t_out[3]=0;
+            aux_accuracy[0] = 0;
+            aux_accuracy[1] = 0;
+            aux_pe = 0;
+            aux_timelapse;
+            timelapse_t[1]=0;
+            timelapse_t[2]=0;
+            timelapse_t[3]=0;
+            ladoTimelapse = 0;
+            modoTimelapse = 0;
+
+            if((ingreso_app == '$')||(ingreso_app == 'S')||(ingreso_app == 'V')||(ingreso_app == 'J')||(ingreso_app == 'L')||(ingreso_app == 'P')||(ingreso_app == 'T')) {
+                if(ingreso_app == 'S') {
+                    estado_recepcion_app = S1;
+                }
+                if(ingreso_app == 'V') {
+                    estado_recepcion_app = V1;
+                }
+                if(ingreso_app == 'J') {
+                    estado_recepcion_app = HAB_JOYSTICK;
+                }
+                if(ingreso_app == 'L') {
+                    estado_recepcion_app = LOOP_HAB;
+                }
+                if(ingreso_app == 'T') {
+                    estado_recepcion_app = TIMELAPSE;
+                }
+                if(ingreso_app == 'P') {
+                    estado_recepcion_app = PUNTOE;
+                    aux_pe = 1;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case S1:
+
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    estado_recepcion_app = S2;
+                    //RECIBO PRIMER DIGITO
+                    aux_slide[0] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case S2:
+
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    estado_recepcion_app = S3;
+                    //RECIBO SEGUNDO DIGITO
+                    aux_slide[1] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case S3:
+
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    estado_recepcion_app = TILT;
+                    //RECIBO TERCER DIGITO
+                    aux_slide[2] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case TILT:
+
+            if((ingreso_app == '$')||(ingreso_app == 'T')) {
+                if(ingreso_app == 'T') {
+                    estado_recepcion_app = T1;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case T1:
+
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    estado_recepcion_app = T2;
+                    //RECIBO PRIMER DIGITO
+                    aux_tilt[0] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case T2:
+
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    estado_recepcion_app = T3;
+                    //RECIBO SEGUNDO DIGITO
+                    aux_tilt[1] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case T3:
+
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    estado_recepcion_app = PAN;
+                    //RECIBO TERCER DIGITO
+                    aux_tilt[2] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case PAN:
+
+            if((ingreso_app == '$')||(ingreso_app == 'P')) {
+                if(ingreso_app == 'P') {
+                    estado_recepcion_app = P1;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case P1:
+
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    estado_recepcion_app = P2;
+                    //RECIBO PRIMER DIGITO
+                    aux_pan[0] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case P2:
+
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    estado_recepcion_app = P3;
+                    //RECIBO SEGUNDO DIGITO
+                    aux_pan[1] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case P3:
+
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    estado_recepcion_app = CRC;
+                    //RECIBO TERCER DIGITO
+                    aux_pan[2] = ingreso_app;
+                    trama_recibida = VALORES_MOTOR;
+
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case V1:
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='1'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='1')) {
+                    estado_recepcion_app = V2;
+                    //RECIBO PRIMER DIGITO
+                    aux_vel[0] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case V2:
+
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    estado_recepcion_app = CRC;
+                    //RECIBO SEGUNDO DIGITO
+                    aux_vel[1] = ingreso_app;
+                    trama_recibida = VELOCIDAD_MOTOR;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case HAB_JOYSTICK:
+
+            if((ingreso_app == '$')||(ingreso_app=='A')||(ingreso_app=='R')) {
+                if(ingreso_app == 'A') {
+                    estado_recepcion_app = CRC;
+                    trama_recibida = MODO_DE_CONTROL;
+                    //RECIBO VALOR
+                    aux_modo = APP;
+
+                }
+                if(ingreso_app == 'R') {
+                    estado_recepcion_app = CRC;
+                    trama_recibida = MODO_DE_CONTROL;
+                    //RECIBO VALOR
+                    aux_modo = CONTROL;
+
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case LOOP_HAB:
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='1'))) {
+                if(ingreso_app=='0') {
+                    aux_loop = DESHABILITADO;
+                    estado_recepcion_app = CRC;
+                    trama_recibida = CONF_LOOP;
+                    //RECIBO PRIMER DIGITO
+                }
+                if(ingreso_app=='1') {
+                    aux_loop = HABILITADO;
+                    estado_recepcion_app = L_DELAY1;
+                    //RECIBO PRIMER DIGITO
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case L_DELAY1:
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    t_delay[1] = ingreso_app;
+                    estado_recepcion_app = L_DELAY2;
+                    //RECIBO PRIMER DIGITO
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case L_DELAY2:
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    t_delay[2] = ingreso_app;
+                    estado_recepcion_app = LD_UNIDAD;
+                    //RECIBO PRIMER DIGITO
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case LD_UNIDAD:
+            if((ingreso_app == '$')||(ingreso_app>='S')||(ingreso_app<='M')||(ingreso_app<='H')) {
+                if(ingreso_app=='S') {
+                    t_delay[3] = SEGUNDOS;
+                    estado_recepcion_app = L_TIMEOUT1;
+                    //RECIBO PRIMER DIGITO
+                }
+                if(ingreso_app=='M') {
+                    t_delay[3] = MINUTOS;
+                    estado_recepcion_app = L_TIMEOUT1;
+                    //RECIBO PRIMER DIGITO
+                }
+                if(ingreso_app=='H') {
+                    t_delay[3] = HORAS;
+                    estado_recepcion_app = L_TIMEOUT1;
+                    //RECIBO PRIMER DIGITO
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case L_TIMEOUT1:
+            if((ingreso_app == '$')||(ingreso_app == 'N')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    t_out[1] = ingreso_app;
+                    estado_recepcion_app = L_TIMEOUT2;
+                    //RECIBO PRIMER DIGITO
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+                if(ingreso_app == 'N') {
+                    t_out[1] = '0';
+                    estado_recepcion_app = L_TIMEOUT2;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case L_TIMEOUT2:
+            if((ingreso_app == '$')||(ingreso_app == 'C')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    t_out[2] = ingreso_app;
+                    estado_recepcion_app = LT_UNIDAD;
+                    //RECIBO PRIMER DIGITO
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+                if(ingreso_app == 'C') {
+                    t_out[2] = '0';
+                    estado_recepcion_app = LT_UNIDAD;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case LT_UNIDAD:
+            if((ingreso_app == '$')||(ingreso_app>='S')||(ingreso_app<='M')||(ingreso_app<='H')) {
+                if(ingreso_app=='S') {
+                    t_out[3] = SEGUNDOS;
+                    estado_recepcion_app = CRC;
+                    //RECIBO PRIMER DIGITO
+                    trama_recibida = CONF_LOOP;
+                }
+                if(ingreso_app=='M') {
+                    t_out[3] = MINUTOS;
+                    estado_recepcion_app = CRC;
+                    //RECIBO PRIMER DIGITO
+                    trama_recibida = CONF_LOOP;
+                }
+                if(ingreso_app=='H') {
+                    t_out[3] = HORAS;
+                    estado_recepcion_app = CRC;
+                    //RECIBO PRIMER DIGITO
+                    trama_recibida = CONF_LOOP;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case PUNTOE:
+            if((ingreso_app == '$')||(ingreso_app>='R')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    aux_accuracy[0] = ingreso_app;
+                    estado_recepcion_app = PRECISION;
+
+                }
+                if(ingreso_app>='R') {
+                    aux_pe = DESHABILITADO;
+                    estado_recepcion_app = CRC;
+                    trama_recibida = PUNTO_E;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case PRECISION:
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = CRC;
+                    aux_pe = HABILITADO;
+                    trama_recibida = PUNTO_E;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case TIMELAPSE:
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='1'))) {
+                if(ingreso_app=='0') {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = CRC;
+                    aux_timelapse = DESHABILITADO;
+                    trama_recibida = TIME_LAPSE;
+                }
+                if(ingreso_app=='1') {
+                    estado_recepcion_app = T_DURACION;
+                    aux_timelapse = HABILITADO;
+                    trama_recibida = TIME_LAPSE;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+
+        case T_DURACION:
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = T_DURACION2;
+                    timelapse_t[1] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case T_DURACION2:
+            if((ingreso_app == '$')||((ingreso_app>='0')&&(ingreso_app<='9'))) {
+                if((ingreso_app>='0')&&(ingreso_app<='9')) {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = T_UNIDAD;
+                    timelapse_t[2] = ingreso_app;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case T_UNIDAD:
+            if((ingreso_app == '$')||(ingreso_app == 'S')||(ingreso_app == 'M')||(ingreso_app == 'H')) {
+                if(ingreso_app == 'S') {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = T_LADO;
+                    timelapse_t[3] = SEGUNDOS;
+                }
+                if(ingreso_app == 'M') {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = T_LADO;
+                    timelapse_t[3] = MINUTOS;
+                }
+                if(ingreso_app == 'H') {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = T_LADO;
+                    timelapse_t[3] = HORAS;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case T_LADO:
+            if((ingreso_app == '$')||(ingreso_app == 'I')||(ingreso_app == 'D')) {
+                if(ingreso_app == 'D') {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = T_MODO;
+                    ladoTimelapse = DERECHA;
+                }
+                if(ingreso_app == 'I') {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = T_MODO;
+                    ladoTimelapse = IZQUIERDA;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case T_MODO:
+            if((ingreso_app == '$')||(ingreso_app == 'P')||(ingreso_app == 'E')||(ingreso_app == 'M')) {
+                if(ingreso_app == 'P') {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = CRC;
+                    modoTimelapse = 1;
+                }
+                if(ingreso_app == 'M') {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = CRC;
+                    modoTimelapse = 2;
+                }
+                if(ingreso_app == 'H') {
+                    //aux_accuracy[1] = ingreso_app;
+                    estado_recepcion_app = CRC;
+                    modoTimelapse = 3;
+                }
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+            } else {
+                estado_recepcion_app = START;
+            }
+            break;
+        case CRC:
+            //Guardo valor CRC
+            crc = ingreso_app;
+            estado_recepcion_app = FIN;
+            break;
+        case FIN:
+
+            if((ingreso_app == '$')||(ingreso_app == '!')) {
+                if(ingreso_app == '$') {
+                    estado_recepcion_app = INICIO;
+                }
+                if(ingreso_app == '!') {
+                    if(crc == 'e') {
+                        if(trama_recibida == CONF_LOOP) {
+                            loop = aux_loop;
+                            estado_maq_loop = ESPERO;
+                            loopRetraso = ((t_delay[1]-0x30)*10+(t_delay[2]-0x30));
+                            loopRetrasoUnidadDeTiempo = t_delay[3];
+                            loopDetenerseUnidadDeTiempo = t_out[3];
+                            loopDetenerse = ((t_out[1]-0x30)*10+(t_out[2]-0x30));
+                            if(loopDetenerse != 0) {
+                                switch(loopDetenerseUnidadDeTiempo) {
+                                    case SEGUNDOS:
+                                        desactivar_loop.attach(&off_loop,loopDetenerse);
+                                        break;
+                                    case MINUTOS:
+                                        desactivar_loop.attach(&off_loop,loopDetenerse*60);
+                                        break;
+                                    case HORAS:
+                                        desactivar_loop.attach(&off_loop,loopDetenerse * 60); // Falta multiplicar por 60 mas
+                                        break;
+                                }
+                            }
+                        }
+                        estado_recepcion_app = START;
+                        if(trama_recibida == TIME_LAPSE) {
+                            if(aux_timelapse==HABILITADO) {
+                                stateTimelapse = HABILITADO;
+                                tiempoTimelapse = ((timelapse_t[1]-0x30)*10+(timelapse_t[2]-0x30));;
+                                unidadtiempoTimelapse = timelapse_t[3];
+                                lado_Timelapse = ladoTimelapse;
+                                modo_Timelapse = modoTimelapse;
+                                loop = DESHABILITADO;
+                                off_loop();
+                            } else if(aux_timelapse==DESHABILITADO) {
+                                stateTimelapse = DESHABILITADO;
+                            }
+
+
+                        }
+                        if(trama_recibida == VALORES_MOTOR) {
+                            app_VSlide = ((aux_slide[0]-0x30)*100+(aux_slide[1]-0x30)*10+(aux_slide[2]-0x30));
+                            app_VTilt = ((aux_tilt[0]-0x30)*100+(aux_tilt[1]-0x30)*10+(aux_tilt[2]-0x30));
+                            app_VPan = ((aux_pan[0]-0x30)*100+(aux_pan[1]-0x30)*10+(aux_pan[2]-0x30));
+                        }
+                        if(trama_recibida == PUNTO_E) {
+                            punto_especifico = aux_pe;
+                            posicion_slide = pasos_slide;
+                            posicion_pan = pasos_pan;
+
+                        }
+                        if(trama_recibida == VELOCIDAD_MOTOR) {
+                            intensidad_VSlide = ((aux_vel[0]-0x30)*10+(aux_vel[1]-0x30));
+                        }
+                        if(trama_recibida == MODO_DE_CONTROL) {
+                            modo_de_funcionamiento = aux_modo;
+                        }
+
+                    }
+                } else {
+                    estado_recepcion_app = START;
+                }
+            }
+            break;
+    }
+}
+void MAQ_recepcion_control()
+{
+    static int aux_slide[3];
+    static int aux_tilt[3];
+    static int aux_pan[3];
+    static int aux_botones[2];
+    static int crc;
+
+    switch(estado_recepcion_control) {
+        case START:
+
+            // Reseteo todas las variables
+            aux_slide[0] = 0;
+            aux_slide[1] = 0;
+            aux_slide[2] = 0;
+            aux_tilt[0] = 0;
+            aux_tilt[1] = 0;
+            aux_tilt[2] = 0;
+            aux_pan[0] = 0;
+            aux_pan[1] = 0;
+            aux_pan[2] = 0;
+            aux_botones[0] = 0;
+            aux_botones[1] = 0;
+            crc = 0;
+
+            if(ingreso_control == '$') {
+                estado_recepcion_control = SLIDE;
+            }
+            break;
+
+        case SLIDE:
+
+            if((ingreso_control == '$')||(ingreso_control == 'S')) {
+                if(ingreso_control == 'S') {
+                    estado_recepcion_control = S1;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case S1:
+
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = S2;
+                    //RECIBO PRIMER DIGITO
+                    aux_slide[0] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case S2:
+
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = S3;
+                    //RECIBO SEGUNDO DIGITO
+                    aux_slide[1] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case S3:
+
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = TILT;
+                    //RECIBO TERCER DIGITO
+                    aux_slide[2] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+        case TILT:
+            if((ingreso_control == '$')||(ingreso_control == 'T')) {
+                if(ingreso_control == 'T') {
+                    estado_recepcion_control = T1;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case T1:
+
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = T2;
+                    //RECIBO PRIMER DIGITO
+                    aux_tilt[0] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case T2:
+
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = T3;
+                    //RECIBO SEGUNDO DIGITO
+                    aux_tilt[1] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case T3:
+
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = PAN;
+                    //RECIBO TERCER DIGITO
+                    aux_tilt[2] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+        case PAN:
+
+            if((ingreso_control == '$')||(ingreso_control == 'P')) {
+                if(ingreso_control == 'P') {
+                    estado_recepcion_control = P1;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case P1:
+
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = P2;
+                    //RECIBO PRIMER DIGITO
+                    aux_pan[0] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case P2:
+
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = P3;
+                    //RECIBO SEGUNDO DIGITO
+                    aux_pan[1] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case P3:
+
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = BOTONES;
+                    //RECIBO TERCER DIGITO
+                    aux_pan[2] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+        case BOTONES:
+
+            if((ingreso_control == '$')||(ingreso_control == 'B')) {
+                if(ingreso_control == 'B') {
+                    estado_recepcion_control = B1;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case B1:
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                //if((ingreso_control == '$')||((ingreso_control>=(0b1100+0x30))&&(ingreso_control<=(0b1111+0x30)))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = B2;
+                    //RECIBO PRIMER DIGITO
+                    aux_botones[0] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case B2:
+            if((ingreso_control == '$')||((ingreso_control>='0')&&(ingreso_control<='9'))) {
+                //if((ingreso_control == '$')||((ingreso_control>=(0b1100+0x30))&&(ingreso_control<=(0b1111+0x30)))) {
+                if((ingreso_control>='0')&&(ingreso_control<='9')) {
+                    estado_recepcion_control = CRC;
+                    //RECIBO SEGUNDO DIGITO
+                    aux_botones[1] = ingreso_control;
+                }
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+            } else {
+                estado_recepcion_control = START;
+            }
+            break;
+
+        case CRC:
+
+            //Guardo valor CRC
+            crc = ingreso_control;
+            estado_recepcion_control = FIN;
+
+            break;
+
+        case FIN:
+            if((ingreso_control == '$')||(ingreso_control == '!')) {
+                if(ingreso_control == '$') {
+                    estado_recepcion_control = SLIDE;
+                }
+                if(ingreso_control == '!') {
+                    if(crc == 'e') {
+                        estado_recepcion_control = START;
+                        joystick_VSlide = ((aux_slide[0]-0x30)*100+(aux_slide[1]-0x30)*10+(aux_slide[2]-0x30));
+                        joystick_VTilt = ((aux_tilt[0]-0x30)*100+(aux_tilt[1]-0x30)*10+(aux_tilt[2]-0x30));
+                        joystick_VPan = ((aux_pan[0]-0x30)*100+(aux_pan[1]-0x30)*10+(aux_pan[2]-0x30));
+                    }
+                } else {
+                    estado_recepcion_control = START;
+                }
+            }
+    }
+}
diff -r 000000000000 -r 1a9bfeb27157 mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Wed Nov 20 13:14:55 2019 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/users/mbed_official/code/mbed/builds/65be27845400
\ No newline at end of file