![](/media/cache/img/default_profile.jpg.50x50_q85.jpg)
CODIGO FINAL PROYECTO
Diff: main.cpp
- Revision:
- 0:1a9bfeb27157
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; + } + } + } +}