/*

WEB: TELEMAXTRONICS.COM
AUTOR:ING. PEDRO NIEVES

*/

/* lIBRERIAS NECESARIAS PARA EL CODIGO*/

#include <EEPROM.h>
#include <Wire.h>
//#include <LiquidCrystal.h>
#include <SPI.h>
#include <Keypad.h>
#include <Stepper.h>
#include <AccelStepper.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
#include <MemoryFree.h>
/* DECLARACIÓN DE CONSNTANTES NECESARIAS PARA EL CODIGO*/

//Sensores limitadores del carro CV

#define sensor1 28
#define sensor2 29

#define releH 22//Rele de la sierra -horizontal

#define finalV 42//final de carrera carroCV
#define releP 44//activacion del releP
#define sensorP 46//final de carrera releP
#define finalI 26//final de carrera tercero horizontal
#define finalE 19//NA
#define finalCV1 36//sensor 1 del cv al final
#define finalCV 40//sensor del cv al final

const int stepPinVT = 11;//NA

const int dirPinVT = 10;//NA

/* DECLARACIÓN DE VARIABLES GLOBALES NECESARIAS PARA EL CODIGO*/

int thspeed, pasonsr2;
float prolijoh = 15, pasos2;
int cuenta_corte, cuenta_cadena;
float cortehcadena[4];
int cc = 0, hh = 0, xx1, xx2, xx3;
int var3 = 0, posi = 0;
char datos[13];
char datosok, a;
int sensorPP = 0;
boolean segmentacion;
String dt, data;
int x1 = 0;
byte ledPin = 13;
boolean blink = false;
boolean ledPin_state;
String msg;
int counter1 = 1, vertical, terceroV, fcv, fcv1, thactivo, thir, thdevolver, smayor, negativo, ptv1, serial,
rh1;
float calib, calib4, calibcp, calibtv, p11 = 0, p22 = 0, p33 = 0, p44 = 0, c11 = 0, c22 = 0, c33 = 0, pasos,
cuenta1, recordar;
float res1, resul, resc1, leerc, res = 0, pos, pos1, resta, poscp, ptv, poscv, posth, cero, profun,
ajuste_recordar;
int counter = 1, cnt = 0, p1 = 0, p2 = 0, p3 = 0, p4 = 0, p5 = 0, rt1 = 0, y11, t2 = 0, t3 = 0, t4 = 0, t5 = 0,
subir, salir, t6 = 0;
int cal, refi, desp, fv, fi, fe, rt, y1, coma, medida, velocidad, error, pasosmm, ss1, ss2;
float cali[10], var1;
int coma1 = 0, var2;
long int ptvrd = 0; //,pasosround=0;
long pasosround = 0;
unsigned long loopCount;
unsigned long startTime;

//Inicializala libreria AccelStepper con los pines correspondientes

AccelStepper carroCV(1, 9, 8, true);
AccelStepper carroTH(1, 11, 10, true);

//Inicializala libreria de lcd con el modelo

#define I2C_ADDR 0x27
LiquidCrystal_I2C lcd(I2C_ADDR,2, 1, 0, 4, 5, 6, 7);

//configurar el teclado: columnas y filas

char customKey;
const byte ROWS = 4; //para fila
const byte COLS = 4; //para columna

char hexaKeys[ROWS][COLS] = {//indicar el valor char en cada poscion del teclado

{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'K'}
};

byte rowPins[ROWS] = {65, 64, 63, 62}; ///pines de las filas

byte colPins[COLS] = {69, 68, 67, 66}; //pines de las columnas

//INICIALIZAR LA LIBRERÍA DE TECLADO

Keypad keypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

//VARIABLES FLOAT GRUPALES PARA ESCRIBIR Y LEER EEPROM

union Float_Byte2 { //CP

float datoF2;
byte datoB2[4];
} unionFB2;
union Float_Byte3 { //TV
float datoF3;
byte datoB3[4];
} unionFB3;
union Float_Byte6 { //TV
float datoF6;
byte datoB6[4];
} unionFB6;
union Float_Byte5 {
float datoF5; //ajustar
byte datoB5[4];
} unionFB5;
union Float_Byte7 {
 float datoF7; //ajustar
byte datoB7[4];
} unionFB7;
union Float_Byte8 {
float datoF8; //ajustar
byte datoB8[4];
} unionFB8;
union Float_Byte1 {
float datoF1; //ajustar
byte datoB1[4];
} unionFB1;
union Float_Byte4 { //ct
float datoF4;
byte datoB4[4];
} unionFB4;
union Float_Byte { //ct
float datoF;
byte datoB[4];
} unionFB;
union Integer_Byte {
int datoI;
byte datoB[2];
} unionIB;
char charN;
/*------CONFIGURACION E INICILIZACION DE ELEMENTOS-----*/
void setup() {
//CONFIGURAMOS PARAMETROS DE MOTOR CV
carroCV.setMaxSpeed(300.0);
carroCV.setAcceleration(100.0);
carroCV.setSpeed(40);
carroCV.moveTo(0);

//CONFIGURAMOS PARAMETROS DE MOTOR TH

carroTH.setMaxSpeed(3600.0);
carroTH.setAcceleration(3400.0);
carroTH.setSpeed(2400);
carroTH.moveTo(0);

//ASIGNAR VALOR A VARIABLES

vertical = 5000;
terceroV = 5000;
pasosmm = 300.5 / 1000;

//DEFINIMOS LAS SALIDAS Y ENTRADAS DIGITALES

pinMode(stepPinVT, OUTPUT);
pinMode(dirPinVT, OUTPUT);
pinMode(finalCV, INPUT_PULLUP);
pinMode(finalCV1, INPUT_PULLUP);
pinMode(finalE, INPUT);
pinMode(finalI, INPUT);
pinMode(finalV, INPUT);
pinMode(sensorP, INPUT);
pinMode(sensor1, INPUT_PULLUP);
pinMode(sensor2, INPUT_PULLUP);
pinMode(62, OUTPUT), (63, OUTPUT), (64, OUTPUT), (65, OUTPUT);
pinMode(67, INPUT), (68, INPUT), (69, INPUT), (66, INPUT);
pinMode(ledPin, OUTPUT), pinMode(stepPinVT, OUTPUT), (dirPinVT, OUTPUT);
pinMode(releH, OUTPUT);
digitalWrite(releH, HIGH);
pinMode(releP, OUTPUT);
digitalWrite(releP, HIGH);
//CONFIGURAMOS PUERTOS SERIALES
Serial.begin(115200);
Serial3.begin(9600);
Serial2.begin(9600);

//INICIALIZAR LCD
lcd.begin (20,4);// Inicializar el display con 20 caraceres 4 lineas
lcd.setBacklightPin(3,POSITIVE);
lcd.setBacklight(HIGH);//ENCENDER EL LED INTERNO DE LA LCD
lcd.home ();//IR AL INICIO
lcd.clear();
lcd.print(" MLPLAK");//
delay(100);

//LEEMOS LOS DATOS EN LA MEMORIA EEPROM

unionFB1.datoB1[0] = EEPROM.read(50);
unionFB1.datoB1[1] = EEPROM.read(51);
unionFB1.datoB1[2] = EEPROM.read(52);
unionFB1.datoB1[3] = EEPROM.read(53);

unionFB5.datoB5[0] = EEPROM.read(90);
unionFB5.datoB5[1] = EEPROM.read(91);
unionFB5.datoB5[2] = EEPROM.read(92);
unionFB5.datoB5[3] = EEPROM.read(93);

unionFB2.datoB2[0] = EEPROM.read(60);
unionFB2.datoB2[1] = EEPROM.read(61);
unionFB2.datoB2[2] = EEPROM.read(62);
unionFB2.datoB2[3] = EEPROM.read(63);

unionFB3.datoB3[0] = EEPROM.read(70);
unionFB3.datoB3[1] = EEPROM.read(71);
unionFB3.datoB3[2] = EEPROM.read(72);
unionFB3.datoB3[3] = EEPROM.read(73);

unionFB4.datoB4[0] = EEPROM.read(80);
unionFB4.datoB4[1] = EEPROM.read(81);
unionFB4.datoB4[2] = EEPROM.read(82);
unionFB4.datoB4[3] = EEPROM.read(83);

unionFB6.datoB6[0] = EEPROM.read(94);
unionFB6.datoB6[1] = EEPROM.read(95);
unionFB6.datoB6[2] = EEPROM.read(96);
unionFB6.datoB6[3] = EEPROM.read(97);

unionFB7.datoB7[0] = EEPROM.read(100);
unionFB7.datoB7[1] = EEPROM.read(101);
unionFB7.datoB7[2] = EEPROM.read(102);
unionFB7.datoB7[3] = EEPROM.read(103);

unionFB8.datoB8[0] = EEPROM.read(110);
unionFB8.datoB8[1] = EEPROM.read(111);
unionFB8.datoB8[2] = EEPROM.read(112);
unionFB8.datoB8[3] = EEPROM.read(113);

unionFB.datoB[0] = EEPROM.read(10);
unionFB.datoB[1] = EEPROM.read(11);
unionFB.datoB[2] = EEPROM.read(12);
unionFB.datoB[3] = EEPROM.read(13);
fv = digitalRead(finalI);
unionIB.datoB[0] = EEPROM.read(30);
unionIB.datoB[1] = EEPROM.read(31);

//ALGUNAS CONDICIONES SI LOS VALORES DE LA EEPROM NO SON LOS ESPERADOS

resta = unionFB1.datoF1;
if (resta > 250) {
resta = 11;
}
if ((unionFB4.datoB4[0] > 254) && (unionFB4.datoB4[1] > 254)) {
unionFB4.datoF4 = 188.4;
}
if ((unionFB7.datoB7[0] > 254) && (unionFB7.datoB7[1] > 254)) {
unionFB7.datoF7 = 15;
}
if ((unionFB.datoB[0] > 254) && (unionFB.datoB[1] > 254)) {
unionFB.datoF = 0.1;
}
if ((unionFB2.datoB2[0] > 254) && (unionFB2.datoB2[1] > 254)) {
unionFB2.datoF2 = 60;
}
if ((unionFB3.datoB3[0] > 254) && (unionFB3.datoB3[1] > 254)) {
unionFB3.datoF3 = 10;
}
if ((unionFB6.datoB6[0] > 254) && (unionFB6.datoB6[1] > 254)) {
unionFB6.datoF6 = 62;
}
if ((unionFB5.datoB5[0] > 254) && (unionFB5.datoB5[1] > 254)) {
unionFB5.datoF5 = 72;
}
if ((unionFB8.datoB8[0] > 254) && (unionFB8.datoB8[1] > 254)) {
unionFB8.datoF8 = 10;
}

ajuste_recordar = unionFB8.datoF8;

if (unionIB.datoI < 0) {
desp = 500;
} else {
desp = unionIB.datoI;
}
refi = EEPROM.read(20);
if (refi > 254) {
refi = 5;
}
velocidad = 640;
error = 0;
thspeed = 340;
if (desp < 1) {
desp = 0;
 }
//Ajustar corte V carroV altura
subir = 384;
rh1 = 0;
salir = unionFB5.datoF5;
thir = salir - 22;
cero = unionFB6.datoF6;
prolijoh = unionFB7.datoF7;
thdevolver = 50;
//Ajustar corte H carroV altura

resta = -unionFB4.datoF4;
lcd.setCursor(1, 1), lcd.print("Bienvenido!");
delay(4800);
lcd.clear();//limpiar lcd
carroCV.setCurrentPosition(0);
delay(300);
Serial2.print("s");//resetear valores en la pagina
cvu();
inicio();//INCIAR EL TH VOLVIENDO A CERO
}

int condicionV() {
if ((poscv <= 120 && poscv >= 70) || (poscv <= 220 && poscv >= 170) || (poscv <= 320 && poscv >=
270) || (poscv <= 420 && poscv >= 370) || (poscv <= 520 && poscv >= 470) || (poscv <= 620 &&
poscv >= 570) || (poscv <= 720 && poscv >= 670) || (poscv <= 820 && poscv >= 770) || (poscv <= 920
&& poscv >= 870) || (poscv <= 1020 && poscv >= 970) || (poscv <= 1120 && poscv >= 1070) || (poscv
<= 1220 && poscv >= 1170) || (poscv <= 1320 && poscv >= 1270) || (poscv <= 1420 && poscv >=
1370) || (poscv <= 1520 && poscv >= 1470) || (poscv <= 1620 && poscv >= 1570) || (poscv <= 1720
&& poscv >= 1670) || (poscv <= 1820 && poscv >= 1770) || (poscv <= 1920 && poscv >= 1870) ||
(poscv <= 2020 && poscv >= 1970) || (poscv <= 2120 && poscv >= 2070)) {
return HIGH;
} else {
return LOW;
}

}
/*------VOLVER AL INICIO A CARRO TH-----*/
void inicio() {

main:
fe = digitalRead(finalE);//leer sensor 0 de th
fi = digitalRead(finalI);
lcd.setCursor(1, 1), lcd.print("Iniciando!-TH"); //imprimir en pantalla el inicio de Th
/*SI EL VALOR ES 0 SIGNIFICA QUE EL SENSOR ESTA DESACTIVADO, CUANDO SEA 1 SE PARA EL
MOTOR Y SE INICIA EL SIGUIENTE MOTOR*/
while ((fi == 0)) {
fi = digitalRead(finalI);
if (fi == 1) {
inicio();
}
carroTH.move(1000);
carroTH.run();
}
fi = digitalRead(finalI); //leer sensor 0 de CT
delay(200);
 if (fi == 0) {
goto main;
}
lcd.clear();//limpiar pantalla
carroTH.stop();//parar TH
carroCV.stop();//parar CV
/*ENVIAR VALORES DE VARIABLES DE CALIBRACIÓN A LA PAGINA*/
Serial2.print(";"), Serial2.print(thir), Serial2.print(";"), Serial2.print(unionFB7.datoF7),
Serial2.print(";"), Serial2.print(unionFB6.datoF6), Serial2.print(";"), Serial2.print(unionFB5.datoF5),
Serial2.print(";"), Serial2.print(unionFB3.datoF3 * 3), Serial2.print(";"), Serial2.print(unionFB2.datoF2
* 2), Serial2.print(";"), Serial2.print(unionFB4.datoF4), Serial2.print(";");
inicio2();//ir a siguiente funcion para inicializar CV
}
/*------VOLVER AL INICIO A CARRO CV-----*/
void inicio2() {
fcv = digitalRead(finalCV); //leer sensor 0 de CV
fcv1 = digitalRead(finalCV1); //leer sensor 1 de CV
/*SI LOS 2 SENSORES SE ACTIVA, ES CERO Y SALE DELBUCLE WHILE*/
while ((fcv == 1 || fcv1 == 1)) { //bucle while para cuando alguno de los sensores estan desactivados
lcd.setCursor(1, 2), lcd.print("Iniciando!-CV"); //imprimir en pantalla el inicio de CV
fcv = digitalRead(finalCV);//leer sensor 0
fcv1 = digitalRead(finalCV1);//leer sensor 1
if (fcv == 0 && fcv1 == 0) { //si los sensores son sensores estan activados se salen del bucle y paran
el motor
inicio2();//volver a funcion
}
carroCV.move(5000);//mover -5000 para regresar el motor cv
carroCV.run();//funcion de mover cv
}

lcd.clear();//limpiar lcd
carroCV.stop();//parar cv
thactivo = 0, serial = 0; //poner variables en 0
/*ENVIAR POSICIÓN A LA PAGINA*/
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
loop();//ir a funcion loop del inicio
}
/*------INICIO Y LOOP DEL SISTEMA-RECIBIR DATOS DE ARDUINO"A" POR SERIAL 3-----*/
void loop() {
/*MOSTRAR VALORES EN LA LCD*/
lcd.setCursor(4, 0), lcd.print(" INICIO ");
//lcd.setCursor(15,0),lcd.print(unionFB2.datoF2);
lcd.setCursor(3, 1), lcd.print(" CV:");
lcd.setCursor(9, 1), lcd.print(poscv);
lcd.setCursor(3, 2), lcd.print(" TH:");
lcd.setCursor(9, 2), lcd.print(posth);
loopCount++;
delay(10);
/*SI Serial2 ESTA ACTIVO EL SERIAL3 LEER EL PUERTO los valores provenientes de arduino A*/
if (Serial3.available() > 0) {
while (Serial3.available() > 0) {
charN = Serial3.read();//leer el valor en la variable tipo char "a"
segmentacion = true;//variable en true para activar los condicionales
}
if (segmentacion == true) {
dt = data;
if (charN == 'O') { //si el valor es O para ingresar valor el corte H prolijo
 dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
delay(200);
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
lcd.clear();//limpiar lcd
charN = ' ';
counter1 = 1; //restablecer valor
segmentacion = false;
carroCV.stop();//para carro cv por seguridad
lop2_prolijo();//ir a funcion para agregar corte H prolijo
}

if (charN == 'P') { //si el valor es P para subir cv en caso de corte V o refilar (Prolijo)
lcd.clear();//limpiar lcd
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
lcd.setCursor(0, 0), lcd.print("CV_p Arriba"); //indicar en la lcd que el cv subirá por un corteV o
refilar
delay(300);
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
segmentacion = false;
delay(200);
carroCV.stop();//para carro cv por seguridad
Serial.println("");
cvu_prolijo();//ir a funcion para subir CV
}

if (charN == 'Q') { //si el valor es Q para calibrar valor de th prolijo en el sistema

lcd.clear();//limpiar lcd
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
delay(200);
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
lcd.clear();//limpiar lcd
counter1 = 1; //restablecer valor
segmentacion = false;
thprolijo(); //ir a funcion para editar valor de th prolijo
}

if (charN == 'R') { //si el valor es R para calibrar el Th en el sistema

lcd.clear();//limpiar lcd
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
lcd.clear();
lcd.setCursor(0, 0), lcd.print("calibracion CTH"); //indicar en la lcd que se calibrara el Th
delay(300);
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
counter1 = 1; //restablecer valor
delay(100);
segmentacion = false;
 calibrarth();//ir a funcion para calibrar valor de th
}

if (charN == 'S') { //si el valor es S para calibrar el CV en el sistema

lcd.clear();//limpiar lcd
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
lcd.setCursor(0, 0), lcd.print("calibracion CCV"); //indicar en la lcd que se calibrara el CV
counter1 = 1; //restablecer valor
delay(300);
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
segmentacion = false;
delay(100);
calibrarcv();//ir a funcion para calibrar valor de CV
}

if (charN == 'T') { //si el valor es T para subir cv en caso de corte V o refilar

dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
lcd.clear();//limpiar lcd
lcd.setCursor(0, 0), lcd.print("CV Arriba"); //indicar en la lcd que subira el CV
delay(300);
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
segmentacion = false;
delay(200);
carroCV.stop();//para carro cv por seguridad
cvu();//ir a funcion para subir el CV
}

if (charN == 'U') { //si el valor es U para bajar cv en caso de corte V o refilar

dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
lcd.clear();//limpiar lcd
lcd.setCursor(0, 0), lcd.print("CV Abajo"); //indicar en la lcd que se bajará el CV
delay(200);
Serial.println("");
carroCV.stop();//para carro cv por seguridad
segmentacion = false;
cvd();//ir a funcion para bajar el CV
}

if (charN == 'V') { //si el valor es V para ingresar valor el corte H

charN = ' '; //limpiar valor de char
counter1 = 1; //restablecer valor
counter = 1; //restablecer valor
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
lcd.clear();//limpiar lcd
delay(200);
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
segmentacion = false;
 carroCV.stop();//para carro cv por seguridad
lop2();//ir a funcion para ingresar el valor del corte H
}

if (charN == 'J') { //si el valor es J para ingresar valor el corte H por serial
charN = ' '; //limpiar valor de char
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
lcd.clear();//limpiar lcd
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
segmentacion = false;
carroCV.stop();//para carro cv por seguridad
serial = 1; //indicar valor de serial activado
loop3();//ir a funcion para ingresar el valor del corte H por serial
}

if (charN == 'G') { //si el valor es G para ingresar valor el corte H prolijo por serial
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
lcd.clear();//limpiar lcd
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
segmentacion = false;
carroCV.stop();//para carro cv por seguridad
serial = 1; //indicar valor de serial activado
loop3_prolijo();//ir a funcion para ingresar el valor del corte H prolijo por serial
}

if (charN == 'H') { //si el valor es J para ingresar valor el corte H por serial
charN = ' '; //limpiar valor de char
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
lcd.clear();//limpiar lcd
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
segmentacion = false;
carroCV.stop();//para carro cv por seguridad
serial = 1; //indicar valor de serial activado
rh1 = 1;
loop3();//ir a funcion para ingresar el valor del corte H por serial
}

if (charN == 'I') { //si el valor es G para ingresar valor el corte H prolijo por serial
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
lcd.clear();//limpiar lcd
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
segmentacion = false;
carroCV.stop();//para carro cv por seguridad
serial = 1; //indicar valor de serial activado
rh1 = 1;
loop3_prolijo();//ir a funcion para ingresar el valor del corte H prolijo por serial
}
if (charN == 'X') { //si el valor es X para calibrar elajustar CV en el sistema
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
lcd.clear();//limpiar lcd
delay(200);
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
counter1 = 1; //restablecer valor
segmentacion = false;
ajustarcv();//ir a funcion para calibrar elajustar CV en el sistema
}

if (charN == 'Y') { //si el valor es Y para calibrar otras opciones de calibracion en el sistema
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
counter1 = 1; //restablecer valor
lcd.clear();//limpiar lcd
delay(200);
Serial3.print("OK");//enviar dato a arduino A para confirmar que llego el valor correctamente
Serial.println("");
segmentacion = false;
menu2();//ir a funcion para calibrar otras opciones de calibracion en el sistema
}
if (charN == 'A') { //si en 1 ir a modificar TH salir
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
counter1 = 1; //restablecer valor
segmentacion = false; //restablecer valor
lcd.clear();
delay(100);
counter1 = 1;
thsalir();
}

if (charN == 'B') { //si en 2 ir a modificar TH ajuste 0

dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
counter1 = 1; //restablecer valor
segmentacion = false; //restablecer valor
lcd.clear();
delay(100);
counter1 = 1;
tvajuste0();
}

if (charN == 'C') { //si en 3 ir a modificar Profundidad TH

dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
charN = ' '; //limpiar valor de char
counter1 = 1; //restablecer valor
segmentacion = false; //restablecer valor
delay(100);
lcd.clear();
 counter1 = 1;
profth();
}
segmentacion = false; //restablecer valor
dt = " "; //limpiar valor de char
data = " "; //limpiar valor de char
}
}
loop();
}
/*------INGRESO DE VALOR TH A TRAVÉS DEL WIFI-----*/
void loop3() {
lcd.setCursor(0, 1);
lcd.print("corteH-WF");//indicar que el ingreso del valor th es a traves del wifi
/*MOSTRAR VLOR DE POS EN LA LCD*/
lcd.setCursor(0, 3);
lcd.setCursor(0, 0), lcd.print("POSCV:");
lcd.setCursor(6, 0), lcd.print(poscv); //mostras pos del CV

if (serial == 1) { //si la variable esta activada esperar valor del modulo wifi por serial2
if (Serial2.available() > 0) { //condicion para cuando el serial2 está activo
while (Serial2.available() > 0) {
res = Serial2.parseFloat(); //leer valor como float
if (res <= 0) { //si el valor recibido es menor o igual a cero volver al loop(inicio)
lcd.clear();//limpiar lcd
Serial2.flush();//limpiar serial
loop();//volver al incio
}
if (t2 == 0) { //si t2=0 restar el valor la primera vez
res = res + resta; //sumar el valor de resta
}
if (rh1 == 1) {
rh1 = 0;
if (recordar < (res + ajuste_recordar)) {
lcd.clear();
loop();
} else {
res = recordar - res - ajuste_recordar;
}
delay(100);
lcd.clear();//limpiar lcd
corteH();
}
counter = 1; //resetear valor
delay(100);
lcd.clear();//limpiar lcd
corteH();//ir a corte H
}
serial = 0; //resetar variable serial 0
}
}
//OTRA CONDICION PARA CANCELAR UN CORTE H
if (Serial2.available()) {
while (Serial2.available() > 0) {
a = Serial2.read(); //leer serial en char
segmentacion = true;//poner variable en true para indicar que se recibio un valor para la siguiente
condicion
 }
if (segmentacion == true) {
if (a == 'x') { //si el dato recibido es igual a x
Serial2.flush();//limpiar serial
delay(200);
loop();//volver a loop
}
}
}
delay(100);
hh++;
if (hh > 10000) { //si se pasa el tiempo de 100segundos esperando volver al loop()
hh = 0;
loop();//volver al loop
} else {
loop3();//volver a la funcion sino se cumple la condicion
}
}
/*------INGRESO DE VALOR TH -PROLIJO- A TRAVÉS DEL WIFI-----*/
void loop3_prolijo() {
lcd.setCursor(0, 1);
lcd.print("corteH-WFP");//indicar que el ingreso del valor th prolijo es a traves del wifi
/*MOSTRAR VLOR DE POS EN LA LCD*/
lcd.setCursor(0, 3);
lcd.setCursor(0, 0), lcd.print("POSCV:");
lcd.setCursor(6, 0), lcd.print(poscv); //mostras pos del CV

if (serial == 1) { //si la variable esta activada esperar valor del modulo wifi por serial2
if (Serial2.available() > 0) { //condicion para cuando el serial2 está activo
while (Serial2.available() > 0) {
res = Serial2.parseFloat(); //leer valor como float
if (res <= 0) { //si el valor recibido es menor o igual a cero volver al loop(inicio)
lcd.clear();//limpiar lcd
Serial2.flush();//limpiar serial
loop();//volver al incio
}
if (t2 == 0) { //si t2=0 restar el valor la primera vez
res = res + resta; //sumar el valor de resta
}
if (rh1 == 1) {
rh1 = 0;
if (recordar < (res + ajuste_recordar)) {
lcd.clear();
loop();
} else {
res = recordar - res - ajuste_recordar;
}
delay(100);
lcd.clear();//limpiar lcd
corteH_prolijo();
}
counter = 1; //resetar valor
delay(100);
lcd.clear();//limpiar lcd
corteH_prolijo();//ir a corte H -Prolijo-
}
serial = 0; //resetar variable serial 0
 }
}
//OTRA CONDICION PARA CANCELAR UN CORTE H
if (Serial2.available()) {
while (Serial2.available() > 0) {
a = Serial2.read(); //leer serial en char
segmentacion = true;//poner variable en true para indicar que se recibio un valor para la siguiente
condicion
}
if (segmentacion == true) {
if (a == 'x') { //si el dato recibido es igual a x
Serial2.flush();//limpiar serial
delay(200);
loop();//volver a loop
}
}
}
delay(100);
hh++;
if (hh > 10000) { //si se pasa el tiempo de 100segundos esperando volver al loop()
hh = 0;
loop();//volver al loop
} else {
loop3_prolijo();//volver a la funcion sino se cumple la condicion
}
}

/*------INGRESO DE VALOR TH-----*/

void lop2() {
//MOSTRAR EN LA LCD ALGUNAS OPCIONES
lcd.setCursor(0, 0);
lcd.print("--A--Desde arriba");
lcd.setCursor(0, 1);
lcd.print("--B--Desde abajo");

if (keypad.getKeys()) { /*INGRESO DE TECLADO LA MISMA LOGICA*/

for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;

if (key == 'A') { //si en 1 ir a modificar TH salir

lcd.clear();
delay(100);
counter1 = 1;
rh1 = 1;
loop2();
}

if (key == 'B') { //si en 2 ir a modificar TH ajuste 0

lcd.clear();
delay(100);
counter1 = 1;
loop2();
}
 break;
}
}
}
}
lop2();
}

void loop2() {
lcd.setCursor(0, 1);
lcd.print("corteH(mm)");//indicar que el ingreso del valor th
/*MOSTRAR VLOR DE POS EN LA LCD*/
lcd.setCursor(0, 3);
lcd.setCursor(0, 0), lcd.print("POSCV:");
lcd.setCursor(6, 0), lcd.print(poscv);
lcd.setCursor(0, 2), lcd.print("ANTERIOR: "), lcd.print(recordar);
lcd.setCursor(0, 3), lcd.print("AJUSTE: "), lcd.print(ajuste_recordar);
//lcd.print(pos);
/*SUMATORIA DE VALOR DESPUES DE HABER AGREGADO VARIOS DIGITOS*/
if (counter == 2) {
res = p1;
}
if (counter == 3) {
if (t2 == 0) {
res = (p1 * 10) + p2 + resta;
}
if (t2 == 1) {
res = (p1 * 10) + p2;
}
}
if (counter == 4) {
if (t2 == 0) {
res = (p1 * 100) + (p2 * 10) + p3 + resta;
}
if (t2 == 1) {
res = (p1 * 100) + (p2 * 10) + p3;
}
}
if (counter == 5) {
if (t2 == 0) {
res = (p1 * 1000) + (p2 * 100) + (p3 * 10) + p4 + resta;
}
if (t2 == 1) {
res = (p1 * 1000) + (p2 * 100) + (p3 * 10) + p4;
}
}
if (counter > 6 & coma == 0) {
resc1 = (c11 / 10);
res = res + resc1;
coma = 1;
}
/*CUANDO SE PRESIONA UN BOTON DEL TECLADO*/
if (keypad.getKeys()) {
for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED://caso cuando presiona el boton
 if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;
if (key == '#') { //si tecla pulsada es igual a "#" significa una ',' y procede a agregar los valores
decimales
delay(300);
counter = counter + 4;
rt1 = counter + 5;
lcd.setCursor(rt1, 1);
lcd.print(",");
coma1 = 1;
}
if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//cuando se agg los digitos en la lcd
delay(100);
lcd.setCursor(0, 1);
counter = counter + 1; //suma una posicion en la lcd
if (counter > 6) {
rt = counter + 5; //cuando se agregua una ','
lcd.setCursor(rt, 1);//posicionar cursor
lcd.print(keypad.key[i].kchar);//imprimir el digito en la lcd
}
if (counter < 7) {
rt = counter + 8; //sumatoria del cursor
lcd.setCursor(rt, 1);//agregar posicion en el cursor de la lcd
lcd.print(keypad.key[i].kchar);//imprimir el digito en la lcd
}
}

if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
/*SUMATORIA DE VALOR DESPUES DE HABER AGREGADO VARIOS DIGITOS CUANDO SE PULSA
UN DIGITO*/
delay(100);
if (counter == 2) { //unidad
char hy = keypad.key[i].kchar; //obtener valor tipo char
p1 = char(hy) - 48; //restar el valor de 48 para hacer el casting de char a int
if (p1 < 0) { //si el valor es menor que '0' dejar en 0 para evitar valor negativo
p1 = 0;
}
res = p1;
}
if (counter == 3) { //decena
p2 = keypad.key[i].kchar - 48;
if (p2 < 0) {
p2 = 0;
}
if (t2 == 0) {
res = (p1 * 10) + p2 + resta;
}
if (t2 == 1) {
res = (p1 * 10) + p2;
}
}
if (counter == 4) { //centena
p3 = keypad.key[i].kchar - 48;
if (p3 < 0) {
p3 = 0;
}
 if (t2 == 0) {
res = (p1 * 100) + (p2 * 10) + p3 + resta;
}
if (t2 == 1) {
res = (p1 * 100) + (p2 * 10) + p3;
}
}
if (counter == 5) { //unidad de mil
p4 = keypad.key[i].kchar - 48;
y1 = 1;
if (p4 < 0) {
p4 = 0;
}
if (t2 == 0) {
res = (p1 * 1000) + (p2 * 100) + (p3 * 10) + p4 + resta;
}
if (t2 == 1) {
res = (p1 * 1000) + (p2 * 100) + (p3 * 10) + p4;
}
if (res > 2665) {
res = 2665;
}
}

if (counter > 6) { //decimales

c11 = keypad.key[i].kchar - 48;
if (c11 < 0) {
c11 = 0;
}
resc1 = (c11 / 10); //dividir el valor entre 10
res = res + resc1; //sumar los valores res(entero) y resc1(decimales)
coma = 1; //indica que el resultado final es float
}
}

if ((key == 'K') && (res != 0)) { //cuando se pulsa el digito 'K' y el valor de res(el agregado) no es
cero(0)
counter = 1; //resetear valor
delay(100);
lcd.clear();//limpiar lcd
if (rh1 == 1) {
if (recordar < (res + ajuste_recordar)) { //si el valor ingresado es menor, volver a ingresar
lcd.setCursor(0, 1);
lcd.print("INGRESAR UN VALOR MENOR");
delay(1500);
counter = 1;
res = 0;
lcd.clear();
loop2();//volver a ingresar valor
} else { //si el valor ingresado esta bien aplicar la formula e ir al corte!
if (t6 == 1) {
res = (recordar + resta) - (res - resta + ajuste_recordar);
} else {
res = recordar - (res + ajuste_recordar);
}
counter = 1;
rh1 = 0;
 lcd.clear();
if (t2 == 0 && t6 == 0) {
recordar = res - resta;
} else {
t6 = 0;
recordar = res;
}
t6 = 0;
corteH();
}
}
if (t2 == 0 && t6 == 0) {
recordar = res - resta;
} else {
t6 = 0;
recordar = res;
}

corteH();//ir a corte H
}
if (key == '*') { //si se pulso el digito '*' borrar el digito en la lcd y en el contador del valor
if (counter < 7) {
y1 = 0;
rt = counter + 8;
lcd.setCursor(rt, 1);//posicionar lcd
lcd.print(" ");//limpiar
if (counter > 1) {
counter = counter - 1; //restar 1 al contador
} else {
lcd.setCursor(rt + 1, 1);
lcd.print(" ");
}
}

if (counter > 6 & coma1 == 1 & coma == 0) { //borrar luego de haber agrado el ',' en el teclado
y1 = 0;
counter = counter - 3;
rt = counter + 8;
lcd.setCursor(rt, 1);//posicionar lcd
lcd.print(" ");//limpiar
counter = counter - 1; //restar 1 al contador
coma1 = 0;
coma = 0;
}

if (counter > 6 & coma1 == 1 & coma == 1) { //borrar luego de haber agrado el un decimal
despues de ',' en el teclado
y1 = 0;
rt = counter + 5;
lcd.setCursor(rt, 1);//posicionar lcd
lcd.print(" ");//limpiar
counter = counter - 1; //restar 1 al contador
coma = 0;
}
}
break;
}
 }
}
}
//OTRA CONDICION PARA CANCELAR UN CORTE H
if (Serial2.available()) {
while (Serial2.available() > 0) {
a = Serial2.read(); //leer serial en char
segmentacion = true;//poner variable en true para indicar que se recibio un valor para la siguiente
condicion
}

if (segmentacion == true) {
if (a == 'x') { //si el dato recibido es igual a x
Serial2.flush();//limpiar serial
delay(200);
loop();//volver a loop
}
}
}
loop2();//volver a la funcion
}
/*------INGRESO DE VALOR TH -Prolijo- -----*/
void lop2_prolijo() {
//MOSTRAR EN LA LCD ALGUNAS OPCIONES
lcd.setCursor(0, 0);
lcd.print("--A--Desde arriba");
lcd.setCursor(0, 1);
lcd.print("--B--Desde abajo");

if (keypad.getKeys()) { /*INGRESO DE TECLADO LA MISMA LOGICA*/

for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;

if (key == 'A') { //si en 1 ir a modificar TH salir

lcd.clear();
delay(100);
counter1 = 1;
rh1 = 1;
loop2_prolijo();
}

if (key == 'B') { //si en 2 ir a modificar TH ajuste 0

lcd.clear();
delay(100);
counter1 = 1;
loop2_prolijo();
}

break;
}
}
}
}
lop2_prolijo();
}

void loop2_prolijo() {
lcd.setCursor(0, 1);
lcd.print("corteH(mm)");//indicar que el ingreso del valor th
/*MOSTRAR VLOR DE POS EN LA LCD*/
lcd.setCursor(0, 3);
lcd.setCursor(0, 0), lcd.print("POSCV:");
lcd.setCursor(6, 0), lcd.print(poscv);
lcd.setCursor(0, 2), lcd.print("ANTERIOR: "), lcd.print(recordar);
lcd.setCursor(0, 3), lcd.print("AJUSTE: "), lcd.print(ajuste_recordar);
//lcd.print(pos);
/*SUMATORIA DE VALOR DESPUES DE HABER AGREGADO VARIOS DIGITOS*/
if (counter == 2) {
res = p1;
}
if (counter == 3) {
if (t2 == 0) {
res = (p1 * 10) + p2 + resta;
}
if (t2 == 1) {
res = (p1 * 10) + p2;
}
}
if (counter == 4) {
if (t2 == 0) {
res = (p1 * 100) + (p2 * 10) + p3 + resta;
}
if (t2 == 1) {
res = (p1 * 100) + (p2 * 10) + p3;
}
}
if (counter == 5) {
if (t2 == 0) {
res = (p1 * 1000) + (p2 * 100) + (p3 * 10) + p4 + resta;
}
if (t2 == 1) {
res = (p1 * 1000) + (p2 * 100) + (p3 * 10) + p4;
}
}
if (counter > 6 & coma == 0) {
resc1 = (c11 / 10);
res = res + resc1;
coma = 1;
}
/*CUANDO SE PRESIONA UN BOTON DEL TECLADO*/
if (keypad.getKeys()) {
for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED://caso cuando presiona el boton
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;
if (key == '#') { //si tecla pulsada es igual a "#" significa una ',' y procede a agregar los valores
decimales
delay(300);
counter = counter + 4;
rt1 = counter + 5;
 lcd.setCursor(rt1, 1);
lcd.print(",");
coma1 = 1;
}

if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//cuando se agg los digitos en la lcd
delay(100);
lcd.setCursor(0, 1);
counter = counter + 1; //suma una posicion en la lcd
if (counter > 6) {
rt = counter + 5; //cuando se agregua una ','
lcd.setCursor(rt, 1); //posicionar cursor
lcd.print(keypad.key[i].kchar);//imprimir el digito en la lcd
}
if (counter < 7) {
rt = counter + 8; //sumatoria del cursor
lcd.setCursor(rt, 1);//agregar posicion en el cursor de la lcd
lcd.print(keypad.key[i].kchar);//imprimir el digito en la lcd
}
}

if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
/*SUMATORIA DE VALOR DESPUES DE HABER AGREGADO VARIOS DIGITOS CUANDO SE PULSA
UN DIGITO*/
delay(100);
if (counter == 2) { //unidad
char hy = keypad.key[i].kchar; //obtener valor tipo char
p1 = char(hy) - 48; //restar el valor de 48 para hacer el casting de char a int
if (p1 < 0) { //si el valor es menor que '0' dejar en 0 para evitar valor negativo
p1 = 0;
}
res = p1;
}
if (counter == 3) { //decena
p2 = keypad.key[i].kchar - 48;
if (p2 < 0) {
p2 = 0;
}
if (t2 == 0) {
res = (p1 * 10) + p2 + resta;
}
if (t2 == 1) {
res = (p1 * 10) + p2;
}
}
if (counter == 4) { //centena
p3 = keypad.key[i].kchar - 48;
if (p3 < 0) {
p3 = 0;
}
if (t2 == 0) {
res = (p1 * 100) + (p2 * 10) + p3 + resta;
}
if (t2 == 1) {
res = (p1 * 100) + (p2 * 10) + p3;
}
 }
if (counter == 5) { //unidad de mil
p4 = keypad.key[i].kchar - 48;
y1 = 1;
if (p4 < 0) {
p4 = 0;
}
if (t2 == 0) {
res = (p1 * 1000) + (p2 * 100) + (p3 * 10) + p4 + resta;
}
if (t2 == 1) {
res = (p1 * 1000) + (p2 * 100) + (p3 * 10) + p4;
}
if (res > 2665) {
res = 2665;
}
}
if (counter > 6) { //decimales
c11 = keypad.key[i].kchar - 48;
if (c11 < 0) {
c11 = 0;
}
resc1 = (c11 / 10); //dividir el valor entre 10
res = res + resc1; //sumar los valores res(entero) y resc1(decimales)
coma = 1; //indica que el resultado final es float
}
}

if ((key == 'K') && (res != 0)) { //cuando se pulsa el digito 'K' y el valor de res(el agregado) no es
cero(0)
counter = 1; //resetear valor
delay(100);
lcd.clear();//limpiar lcd
if (rh1 == 1) {
if (recordar < (res + ajuste_recordar)) { //si el valor ingresado es menor, volver a ingresar
lcd.setCursor(0, 1);
lcd.print("INGRESAR UN VALOR MENOR");
delay(1500);
counter = 1;
res = 0;
lcd.clear();
loop2_prolijo();//volver a ingresar valor
} else { //si el valor ingresado esta bien aplicar la formula e ir al corte!
if (t6 == 1) {
res = (recordar + resta) - (res - resta + ajuste_recordar);
} else {
res = recordar - (res + ajuste_recordar);
}
counter = 1;
rh1 = 0;
lcd.clear();
if (t2 == 0 && t6 == 0) {
recordar = res - resta;
} else {
t6 = 0;
recordar = res;
}
 t6 = 0;
corteH_prolijo();
}
}
if (t2 == 0 && t6 == 0) {
recordar = res - resta;
} else {
t6 = 0;
recordar = res;
}
corteH_prolijo();//ir a corte H prolijo
}
if (key == '*') { //si se pulso el digito '*' borrar el digito en la lcd y en el contador del valor
if (counter < 7) {
y1 = 0;
rt = counter + 8;
lcd.setCursor(rt, 1);//posicionar lcd
lcd.print(" ");//limpiar
if (counter > 1) {
counter = counter - 1; //restar 1 al contador
} else {
lcd.setCursor(rt + 1, 1);
lcd.print(" ");
}
}

if (counter > 6 & coma1 == 1 & coma == 0) { //borrar luego de haber agrado el ',' en el teclado
y1 = 0;
counter = counter - 3;
rt = counter + 8;
lcd.setCursor(rt, 1);//posicionar lcd
lcd.print(" ");//limpiar
counter = counter - 1; //restar 1 al contador
coma1 = 0;
coma = 0;
}

if (counter > 6 & coma1 == 1 & coma == 1) { //borrar luego de haber agrado el un decimal
despues de ',' en el teclado
y1 = 0;
rt = counter + 5;
lcd.setCursor(rt, 1);//posicionar lcd
lcd.print(" ");//limpiar
counter = counter - 1; //restar 1 al contador
coma = 0;
}
}
break;
}
}
}
}
//OTRA CONDICION PARA CANCELAR UN CORTE H
if (Serial2.available()) {
while (Serial2.available() > 0) {
a = Serial2.read(); //leer serial en char
segmentacion = true;//poner variable en true para indicar que se recibio un valor para la siguiente
 }

if (segmentacion == true) {
if (a == 'x') { //si el dato recibido es igual a x
Serial2.flush();//limpiar serial
delay(200);
loop();//volver a loop
}
}
}
loop2_prolijo();//volver a la funcion
}
/*------MENU-- PARA ALGUNAS OTRAS OPCIONES------*/
void menu2() {
//MOSTRAR EN LA LCD ALGUNAS OPCIONES
lcd.setCursor(0, 0);
lcd.print("01- AJUSTAR SALIR");
lcd.setCursor(0, 1);
lcd.print("02- AJUSTAR 0 TH ");
lcd.setCursor(0, 2);
lcd.print("03- PROFUNDIDAD TH");
lcd.setCursor(0, 3);
lcd.print("04- RECORDAR TH");

if (keypad.getKeys()) { /*INGRESO DE TECLADO LA MISMA LOGICA*/

for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;

if (key == '1') { //si en 1 ir a modificar TH salir

lcd.clear();
delay(100);
counter1 = 1;
thsalir();
}

if (key == '2') { //si en 2 ir a modificar TH ajuste 0

lcd.clear();
delay(100);
counter1 = 1;
tvajuste0();
}

if (key == '3') { //si en 3 ir a modificar Profundidad TH

delay(100);
lcd.clear();
counter1 = 1;
profth();
}

if (key == '4') { //si en 4 ir a modificar ajuste recordar

delay(100);
lcd.clear();
counter1 = 1;
recordar_th();
 }

if (key == 'C') { //regresar a loop()

counter = 1;
lcd.clear();
delay(100);
loop();
}
break;
}
}
}
}
menu2();
}
/*------CORTE V CONFIGURAR SUBIR CARRO VERTICAL------*/
void cvu() {
//CONFIGURAR PARAMETROS DE VELOCIDAD DEL CARRO VERTICAL A SU FORMA NORMAL
carroCV.setMaxSpeed(450.0);
carroCV.setAcceleration(100.0);
carroCV.setSpeed(20);
carroCV.stop();
ss1 = digitalRead(sensor1); //leer entrada sensor 1
ss2 = digitalRead(sensor2); //leer entreda sensor 2

//CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL

SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE SUMA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1
if (t2 == 1) {
if (poscv < subir) { //si la posicion actual es menor que la variable subir
lcd.setCursor(0, 0), lcd.print("subiendo_200+placa"); //indicar en la lcd que esta subiendo CV
pasos = ((subir - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround);//poner el cv en la libreria en la posicion para regresar a 0
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
carroCV.setAcceleration(200.0);//modificar aceleracion
var1 = -4726; //poner variable en el valor 4726 previamente calibrado
var3 = 1;
var2 = 1;
cvu1();//ir a funcion subir
}
}
if (t2 == 0) {
if (poscv < subir + resta + 1) { //si la posicion actual es menor que la variable subir
lcd.setCursor(0, 0), lcd.print("subiendo200+placa"); //indicar en la lcd que esta subiendo CV
pasos = (((subir + resta) - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //poner el cv en la libreria en la posicion para regresar a 0
carroCV.setCurrentPosition(pasosround);//poner el cv en la libreria en la posicion para regresar a 0
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
carroCV.setAcceleration(200.0);//modificar aceleracion
var1 = -4726; //poner variable en el valor 4726 previamente calibrado
var2 = 1;
var3 = 1;
cvu1();//ir a funcion subir
}
 }
if (ss2 == 0 || ss1 == 0) { // si algunos de los sensores estan activados
lcd.setCursor(0, 0), lcd.print("placa detectada sub"); //indicar que la placa esta detectada
carroCV.setCurrentPosition(50000);//setear posicion en 50000 para mover a 0
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
//mostrar valores de los sensores
lcd.setCursor(0, 1), lcd.print("sensor1: ");
lcd.setCursor(10, 1), lcd.print(ss1);
lcd.setCursor(0, 2), lcd.print("sensor2: ");
lcd.setCursor(10, 2), lcd.print(ss2);
delay(200);
lcd.clear();//limpiar lcd
lcd.setCursor(0, 0), lcd.print("Subiendo"); //indicar en la lcd que seesta subiendo
carroCV.setAcceleration(200.0);//modificar aceleracion
var1 = -(4726 - (poscv / unionFB2.datoF2) * 1000); //poner variable en el valor con la formula
var2 = 1;
cvu1();//ir a funcion para subir
}
if (ss2 == 1 && ss1 == 1) { //si ninguna de los sensores no detecto placa y la poscion actual es mayor
que subir
lcd.setCursor(0, 0), lcd.print("placa NO detectada B"); //indicar que no se ha detectado placa
carroCV.setCurrentPosition(0);//setear poscv en 0
smayor = 0;
cvuu();//ir a funcion de bajar
}
//CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL
SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE SUMA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1
delay(100);
if (t2 == 0) {
if (poscv > subir + resta - 1) { //si la posicion actual es mayor que la variable subir
smayor = 0; //poner variable en 0 o high para usarlo como condicional posteriormente
pasos = ((poscv - (subir + resta)) / unionFB2.datoF2) * 1000; //obtener pasos de la formula para
bajar
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(0); //poner el cv en la libreria en la posicion 0
lcd.setCursor(0, 0), lcd.print("bajando-CV"); //indicar en la lcd que esta bajando CV
cvuu();//ir a funcion de bajar
}
if (poscv < subir + resta + 1) { //si la posicion actual es menor que la variable subir
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
pasos = (((subir + resta) - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround); //poner el cv en la libreria en la posicion para regresar a
0
lcd.setCursor(0, 0), lcd.print("subiendo-CV"); //indicar en la lcd que esta subiendo CV
cvu1();//ir a funcion de subir
}
}

if (t2 == 1) {
if (poscv > subir - 1) { //si la posicion actual es mayor que la variable subir
smayor = 0; //poner variable en 0 o high para usarlo como condicional posteriormente
pasos = ((poscv - subir) / unionFB2.datoF2) * 1000; //obtener pasos de la formula para bajar
pasosround = round(pasos); //redondear pasos
 carroCV.setCurrentPosition(0); //poner el cv en la libreria en la posicion 0
lcd.setCursor(0, 0), lcd.print("bajando-CV"); //indicar en la lcd que esta bajando CV
cvuu();//ir a funcion de bajar
}
if (poscv < subir + 1) { //si la posicion actual es menor que la variable subir
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
pasos = ((subir - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround); //poner el cv en la libreria en la posicion para regresar a
0
lcd.setCursor(0, 0), lcd.print("subiendo-CV"); //indicar en la lcd que esta subiendo CV
cvu1();//ir a funcion de subir
}
}
cvu();//volver a la funcion
}
/*------CORTE V SUBIR HASTA PLACA CARRO VERTICAL------*/
void cvu1() {

ss1 = digitalRead(sensor1); //leer valor del sensor 1

ss2 = digitalRead(sensor2); //leer valor del sensor 2
//a continuacion funcion para modificar la posicion y los pasos durante el recorrido para el proceso
de frenado cuando se detecta la placa
if (var3 == 1) { //si var3 esta en 1 significa que la posicion actual es menor que la de la variable subir
if (carroCV.currentPosition() < 0) { //mover posicion del cv hasta cero
if (ss2 == 1 && ss1 == 1) { //si los sensores ya no detectan placa
if (xx1 == 5 && var2 == 1) { //si xx1 est en 5 significa que ya repitio el ciclo 5 veces y var2 en 1
indica que fue detecata la placa la posicion actual es menor
var1 = carroCV.currentPosition() - 10; //restar 10 a la posicion actual para el proceso de frenado
y guardar en var 1
var2 = 0; //resetar variable en 0
xx1 = 0; //resetar variable en 0
}
if (var2 == 1) { //cuando var2 sea 1 sumar xx1
xx1++;
}
}
}
} else if (var3 == 0) { //si var3 esta en 0 significa que la posicion actual es mayor que la de la variable
subir
if (ss2 == 1 && ss1 == 1) { //si los sensores ya no detectan placa
if (xx1 == 5 && var2 == 1) { //si xx1 est en 5 significa que ya repitio el ciclo 5 veces y var2 en 1
indica que fue detecata la placa la posicion actual er menor
var1 = carroCV.currentPosition() - 10; //restar 10 a la posicion actual para el proceso de frenado
y guardar en var 1
var2 = 0; //resetar variable en 0
xx1 = 0; //resetar variable en 0
}
if (var2 == 1) { //cuando var2 sea 1 sumar xx1
xx1++;
}
}
}

if (carroCV.currentPosition() <= var1) { //si var 1 es menor o igual que la posicion actual
delay(100);
lcd.clear();
 carroCV.stop();
lcd.setCursor(0, 0), lcd.print("no se detecta sensor"); //indicar que no se detecta sensor
lcd.setCursor(0, 1), lcd.print("sensor1: ");
lcd.setCursor(10, 1), lcd.print(ss1); //mostrar valor del sensor 1
lcd.setCursor(0, 2), lcd.print("sensor2: ");
lcd.setCursor(10, 2), lcd.print(ss2); //mostrar valor del sensor 2
delay(100);
xx1 = 0;
carroCV.setAcceleration(100.0);//modificar parametro de aceleracion
var1 = 0; //resetar valor
var3 = 0; //
cvu2();//ir a siguiente funcion
}
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
carroCV.moveTo(var1);//mover hacia la variable editada para el frenado suave
carroCV.run();//mover
cvu1();//volver a funcion
}
/*------CORTE V BAJAR HASTA PLACA CARRO VERTICAL------*/
void cvuu() {
//si la posicion actual es mayor que la variable subir
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
fcv = digitalRead(finalCV);//leer valor del final de carrera 1
fcv1 = digitalRead(finalCV1);//leer valor del final de carrera 2

while (ss2 == 1 & ss1 == 1 & carroCV.currentPosition() < 40000 & fcv == 1) { //si los sensores estan
desactivados y la posicion es menor a 4mil y el final de carrera esta desactivada mover cv hacia abajo
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
fcv = digitalRead(finalCV);//leer valor del final de carrera 1
fcv1 = digitalRead(finalCV1);//leer valor del final de carrera 2
carroCV.move(5000);//mover hacia abajo el cv
carroCV.run();//mover
}
cvu2();//ir a siguiente funcion
}
/*------CORTE V MODIFICAR VALORES DE POSICION------*/
void cvu2() {

lcd.clear();//limpiar lcd
// CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL
SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE RESTA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1

if (t2 == 1) {
delay(100);
lcd.setCursor(10, 2);
if (smayor == 0) { //condicional para indicar que el movimiento fue hacia abajo con smayor en 0
pasos = carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a libreria
poscv = poscv - (pasos * unionFB2.datoF2) / 1000; //modificar valor de posicion de cv
}
if (smayor == 1) { //condicional para indicar que el movimiento fue hacia arriba con smayor en 1
 pasos = 50000 - carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a
libreria+ 5000pasos constantes
poscv = poscv + (unionFB2.datoF2 * pasos) / 1000; //modificar valor de posicion de cv
}

}
if (t2 == 0) {
delay(100);
lcd.setCursor(10, 2);
if (smayor == 0) { //condicional para indicar que el movimiento fue hacia abajo con smayor en 0
pasos = carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a libreria
poscv = poscv - resta - (unionFB2.datoF2 * pasos) / 1000; //modificar valor de posicion de cv
}
if (smayor == 1) { //condicional para indicar que el movimiento fue hacia arriba con smayor en 1
pasos = 50000 - carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a
libreria+ 5000pasos constantes
poscv = poscv - resta + (unionFB2.datoF2 * pasos) / 1000; //modificar valor de posicion de cv
}
t2 = 1;
}
//mostrar valor en la lcd
lcd.setCursor(0, 1), lcd.print(" CV:");
lcd.setCursor(6, 1), lcd.print(poscv);
lcd.setCursor(0, 2), lcd.print(" TH:");
lcd.setCursor(6, 2), lcd.print(posth);
Serial.print("pasos 1564: "), Serial.println(pasos);
Serial.print("resta 1565: "), Serial.println(resta);
Serial.print("unionFB2.datoF2 1567: "), Serial.println(unionFB2.datoF2 );
Serial.print("poscv 1567: "), Serial.println(poscv);
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
delay(200);
carroCV.stop();//para cv por seguridad
Serial3.print("J");//enviar dato a arduinoA que ya se movio el cv para continuar con el corte
Serial.println(" ");
delay(100);
loop();//volver al inicio
}
/*------CORTE V CONFIGURAR BAJAR CV PARA REALIZAR EL CORTE------*/
void cvd() {
//configurar parametros de velocidad y aceleracion de carro CV
carroCV.setMaxSpeed(280.0);
carroCV.setAcceleration(50.0);
carroCV.setSpeed(20);

carroCV.setCurrentPosition(0);//posicion en 0
fcv = digitalRead(finalCV);//leer sensor final de carrera 1
fcv1 = digitalRead(finalCV1);//leer sensor final de carrera 2
lcd.setCursor(0, 1), lcd.print("regresando!-CV"); //indicar en la lcd que se esta regresando cv
lcd.setCursor(0, 2), lcd.print(fcv), lcd.print(","), lcd.print(fcv1);
delay(100);
cvd1();//ir a siguiente funcion
}
/*------CORTE V BAJAR CV PARA REALIZAR EL CORTE------*/
void cvd1() {
fcv = digitalRead(finalCV);//leer sensor final de carrera 1
fcv1 = digitalRead(finalCV1);//leer sensor final de carrera 2
while ((fcv == 1 || fcv1 == 1)) { //mover cv mientras estan desactivados
fcv = digitalRead(finalCV);//leer sensor final de carrera 1
fcv1 = digitalRead(finalCV1);
if (fcv == 0 && fcv1 == 0) { //si los sensores se activan entonces para el cv
lcd.clear();//limpiar lcd
lcd.setCursor(0, 1), lcd.print(fcv), lcd.print(","), lcd.print(fcv1);
poscv = 0; //resetear valor
delay(200);
carroCV.stop();//para cv
Serial3.print("K");//enviar valor al arduino A para indicar que ya bajo el CV hasta el inicio
Serial.println(" ");
delay(100);
poscv = 0, t2 = 0; //resetear valores
t6 = 1;
//enviar dato de pocision a la web
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
loop();//volver al inicion
}
carroCV.move(6000);//mover 5mil para regresar el cv a la posicion cero por el centido invertido
carroCV.run();//mover
}
cvd1(); //volver a funcion
}
/*------CORTE V -PROLIJO- CONFIGURAR SUBIR CARRO VERTICAL------*/
void cvu_prolijo() {
//CONFIGURAR PARAMETROS DE VELOCIDAD DEL CARRO VERTICAL A SU FORMA NORMAL
carroCV.setMaxSpeed(450.0);
carroCV.setAcceleration(100.0);
carroCV.setSpeed(20);
carroCV.stop();
ss1 = digitalRead(sensor1); //leer entrada sensor 1
ss2 = digitalRead(sensor2); //leer entreda sensor 2
//CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL
SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE SUMA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1

if (t2 == 1) {
if (poscv < subir) { //si la posicion actual es menor que la variable subir
lcd.setCursor(0, 0), lcd.print("subiendo200"); //indicar en la lcd que esta subiendo CV
pasos = ((subir - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround);//poner el cv en la libreria en la posicion para regresar a 0
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
carroCV.setAcceleration(200.0);//modificar aceleracion
var1 = -4726; //poner variable en el valor 4726 previamente calibrado
var2 = 1;
var3 = 1;
cvu1_prolijo();//ir a funcion subir
}
}
if (t2 == 0) {
if (poscv < subir + resta + 1) { //si la posicion actual es menor que la variable subir
lcd.setCursor(0, 0), lcd.print("subiendo200"); //indicar en la lcd que esta subiendo CV
pasos = (((subir + resta) - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //poner el cv en la libreria en la posicion para regresar a 0
 carroCV.setCurrentPosition(pasosround);//poner el cv en la libreria en la posicion para regresar a 0
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
carroCV.setAcceleration(200.0);//modificar aceleracion
var1 = -4726; //poner variable en el valor 4726 previamente calibrado
var2 = 1;
var3 = 1;
cvu1_prolijo();//ir a funcion subir
}
}
if (ss2 == 0 || ss1 == 0) { // si algunos de los sensores estan activados
lcd.setCursor(0, 0), lcd.print("placa detectada sub"); //indicar que la placa esta detectada
carroCV.setCurrentPosition(50000);//setear posicion en 50000 para mover a 0
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
//mostrar valores de los sensores
lcd.setCursor(0, 1), lcd.print("sensor1: ");
lcd.setCursor(10, 1), lcd.print(ss1);
lcd.setCursor(0, 2), lcd.print("sensor2: ");
lcd.setCursor(10, 2), lcd.print(ss2);
delay(200);
lcd.clear();//limpiar lcd
lcd.setCursor(0, 0), lcd.print("Subiendo"); //indicar en la lcd que seesta subiendo
var2 = 1;
var1 = -(4726 - (poscv / unionFB2.datoF2) * 1000); //poner variable en el valor con la formula
cvu1_prolijo();//ir a funcion para subir
}
if (ss2 == 1 && ss1 == 1) { //si ninguna de los sensores no detecto placa y la poscion actual es mayor
que subir
lcd.setCursor(0, 0), lcd.print("placa NO detectada B"); //indicar que no se ha detectado placa
carroCV.setCurrentPosition(0);//setear en 0 la posicion
smayor = 0; //poner variable en 0 o high para usarlo como condicional posteriormente
cvuu_prolijo();//ir a funcion para bajar
}
//CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL
SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE SUMA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1

delay(100);
if (t2 == 0) {
if (poscv > subir + resta - 1) { //si la posicion actual es mayor que la variable subir
smayor = 0; //poner variable en 0 o high para usarlo como condicional posteriormente
pasos = ((poscv - (subir + resta)) / unionFB2.datoF2) * 1000; //obtener pasos de la formula para
bajar
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(0);//poner el cv en la libreria en la posicion
lcd.setCursor(0, 0), lcd.print("bajando-CV"); //indicar en la lcd que esta bajando CV
cvuu_prolijo();//ir a funcion de bajar
}
if (poscv < subir + resta + 1) { //si la posicion actual es menor que la variable subir
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
pasos = (((subir + resta) - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround);//poner el cv en la libreria en la posicion para regresar a 0
lcd.setCursor(0, 0), lcd.print("subiendo-CV"); //indicar en la lcd que esta subiendo CV
cvu1_prolijo();//ir a funcion de subir
}
 }
if (t2 == 1) {
if (poscv > subir - 1) { //si la posicion actual es mayor que la variable subir
smayor = 0; //poner variable en 0 o high para usarlo como condicional posteriormente
pasos = ((poscv - subir) / unionFB2.datoF2) * 1000; //obtener pasos de la formula para bajar
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(0);//poner el cv en la libreria en la posicion 0
lcd.setCursor(0, 0), lcd.print("bajando-CV"); //indicar en la lcd que esta bajando CV
cvuu_prolijo();//ir a funcion de bajar
}
if (poscv < subir + 1) { //si la posicion actual es menor que la variable subir
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
pasos = ((subir - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround);//poner el cv en la libreria en la posicion para regresar a 0
lcd.setCursor(0, 0), lcd.print("subiendo-CV"); //indicar en la lcd que esta subiendo CV
cvu1_prolijo();//ir a funcion de subir
}
}
cvu_prolijo();//volver a la funcion
}
/*------CORTE V -PROLIJO- SUBIR HASTA PLACA CARRO VERTICAL------*/
void cvu1_prolijo() {
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
//a continuacion funcion para modificar la posicion y los pasos durante el recorrido para el proceso
de frenado cuando se detecta la placa
if (var3 == 1) { //si var3 esta en 1 significa que la posicion actual es menor que la de la variable subir
if (carroCV.currentPosition() < 0) { //mover posicion del cv hasta cero
if (ss2 == 1 && ss1 == 1) { //si los sensores ya no detectan placa
if (xx1 == 5 && var2 == 1) { //si xx1 est en 5 significa que ya repitio el ciclo 5 veces y var2 en 1
indica que fue detecata la placa la posicion actual es menor
var1 = carroCV.currentPosition() - 10; //restar 10 a la posicion actual para el proceso de frenado
y guardar en var 1
var2 = 0; //resetar variable en 0
xx1 = 0; //resetar variable en 0
}
if (var2 == 1) { //cuando var2 sea 1 sumar xx1
xx1++;
}
}
}
} else if (var3 == 0) { //si var3 esta en 0 significa que la posicion actual es mayor que la de la variable
subir
if (ss2 == 1 && ss1 == 1) { //si los sensores ya no detectan placa
if (xx1 == 5 && var2 == 1) { //si xx1 est en 5 significa que ya repitio el ciclo 5 veces y var2 en 1
indica que fue detecata la placa la posicion actual er menor
var1 = carroCV.currentPosition() - 10; //restar 10 a la posicion actual para el proceso de frenado
y guardar en var 1
var2 = 0; //resetar variable en 0
xx1 = 0; //resetar variable en 0
}
if (var2 == 1) { //cuando var2 sea 1 sumar xx1
xx1++;
}
}
}
 if (carroCV.currentPosition() <= var1) { //si var 1 es menor o igual que la posicion actual
delay(100);
lcd.clear();//limpiar lcd
carroCV.stop();//parar cv
lcd.setCursor(0, 0), lcd.print("no se detecta sensor"); //indicar que no se detecta sensor
lcd.setCursor(0, 1), lcd.print("sensor1: ");
lcd.setCursor(10, 1), lcd.print(ss1); //mostrar valor del sensor 1
lcd.setCursor(0, 2), lcd.print("sensor2: ");
lcd.setCursor(10, 2), lcd.print(ss2); //mostrar valor del sensor 2
delay(100);
xx1 = 0;
carroCV.setAcceleration(100.0);//modificar parametro de aceleracion
var1 = 0; //resetar valor
var3 = 0; //resetar valor
cvu2_prolijo();//ir a siguiente funcion
}
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
carroCV.moveTo(var1);//mover hacia la variable editada para el frenado suave
carroCV.run();//mover
cvu1_prolijo();//volver a funcion
}
/*------CORTE V -PROLIJO- BAJAR HASTA PLACA CARRO VERTICAL------*/
void cvuu_prolijo() {
//si la posicion actual es mayor que la variable subir
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
fcv = digitalRead(finalCV);//leer valor del final de carrera 1
fcv1 = digitalRead(finalCV1);//leer valor del final de carrera 2
while (ss2 == 1 & ss1 == 1 & carroCV.currentPosition() < 40000 & fcv == 1) { //si los sensores estan
desactivados y la posicion es menor a 4mil y el final de carrera esta desactivada mover cv hacia abajo
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
fcv = digitalRead(finalCV);//leer valor del final de carrera 1
fcv1 = digitalRead(finalCV1);//leer valor del final de carrera 2
carroCV.move(5000);//mover hacia abajo el cv
carroCV.run();//mover
}
cvu2_prolijo();//ir a siguiente funcion
}
/*------CORTE V -PROLIJO- MODIFICAR VALORES DE POSICION------*/
void cvu2_prolijo() {

lcd.clear();//limpiar lcd
// CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL
SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE RESTA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1

if (t2 == 1) {
delay(100);
lcd.setCursor(10, 2);
if (smayor == 0) { //condicional para indicar que el movimiento fue hacia abajo con smayor en 0
pasos = carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a libreria
poscv = poscv - (pasos * unionFB2.datoF2) / 1000; //modificar valor de posicion de cv
 }
if (smayor == 1) { //condicional para indicar que el movimiento fue hacia arriba con smayor en 1
pasos = 50000 - carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a
libreria+ 5000pasos constantes
poscv = poscv + (unionFB2.datoF2 * pasos) / 1000; //modificar valor de posicion de cv
}

}
if (t2 == 0) {
delay(100);
lcd.setCursor(10, 2);
if (smayor == 0) { //condicional para indicar que el movimiento fue hacia abajo con smayor en 0
pasos = carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a libreria
poscv = poscv - resta - (unionFB2.datoF2 * pasos) / 1000; //modificar valor de posicion de cv
}
if (smayor == 1) { //condicional para indicar que el movimiento fue hacia arriba con smayor en 1
pasos = 50000 - carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a
libreria+ 5000pasos constantes
poscv = poscv - resta + (unionFB2.datoF2 * pasos) / 1000; //modificar valor de posicion de cv
}
t2 = 1;
}
//mostrar valor en la lcd
lcd.setCursor(0, 1), lcd.print(" CV:");
lcd.setCursor(6, 1), lcd.print(poscv);
lcd.setCursor(0, 2), lcd.print(" TH:");
lcd.setCursor(6, 2), lcd.print(posth);
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
delay(200);
carroCV.stop();//para cv por seguridad
Serial3.print("W");//enviar dato a arduinoA que ya se movio el cv para continuar con el corte
Serial.println(" ");
delay(100);

huto:
delay(50);
while (Serial3.available() > 0) { //esperar serial3 para recibir dato de arduino A
charN = Serial3.read(); //obtener valor leido tipo char
segmentacion = true;
}

if (segmentacion == true) {
dt = data;
Serial.println(dt);
if (charN == 'Z') { //si el valor es Z seguir a la siguiente funcion
delay(100);
cvd_prolijo();//ir a siguiente funcion
}
}
goto huto;//olver etiqueta

}
/*------CORTE V -PROLIJO- CONFIGURAR BAJAR CV PARA REALIZAR EL CORTE------*/
void cvd_prolijo() {
//configurar parametros de velocidad y aceleracion de carro CV
carroCV.setMaxSpeed(350.0);
 carroCV.setAcceleration(50.0);
carroCV.setSpeed(20);

carroCV.setCurrentPosition(0);//posicion en 0
fcv = digitalRead(finalCV);//leer sensor final de carrera 1
fcv1 = digitalRead(finalCV1); //leer sensor final de carrera 2
lcd.setCursor(0, 1), lcd.print("regresando!-CV"); //indicar en la lcd que se esta regresando cv
cvd1_prolijo();//ir a siguiente funcion
}
/*------CORTE V -PROLIJO- BAJAR CV PARA REALIZAR EL CORTE------*/
void cvd1_prolijo() {

fcv1 = digitalRead(finalCV1); //leer sensor final de carrera 1

fcv = digitalRead(finalCV); //leer sensor final de carrera 2

while ((fcv == 1 || fcv1 == 1)) { //mientras no esten desactivados mantener dentro del while y mover
cv
fcv = digitalRead(finalCV);//leer sensor final de carrera 1
fcv1 = digitalRead(finalCV1);//leer sensor final de carrera 2
if (fcv == 0 && fcv1 == 0) { //si los sensores se activan entonces para el cv
lcd.clear();//limpiar lcd
delay(200);
carroCV.stop();//parar cv
Serial3.print("D");//enviar valor al arduino A para indicar que ya bajo el CV hasta el inicio
Serial.println(" ");
delay(100);
poscv = 0, t2 = 0; //resetear valores
t6 = 1;
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
esperar_prolijo2(); //ir al siguiente funcion
}
carroCV.move(5000);//mover 5mil para regresar el cv a la posicion cero por el centido invertido
carroCV.run();//mover
}

if (fcv == 0 && fcv1 == 0) {

lcd.clear();//limpiar lcd
poscv = 0;
delay(200);
carroCV.stop();//parar cv
Serial3.print("D");//enviar valor al arduino A para indicar que ya bajo el CV hasta el inicio
Serial.println(" ");
delay(100);
poscv = 0, t2 = 0; //resetear valores
if (recordar > 0) {
recordar = recordar + resta;
}
t6 = 1;
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
esperar_prolijo2();//ir al siguiente funcion

}
esperar_prolijo2();//ir al siguiente funcion
}
/*------CORTE V -PROLIJO- ESPERA SERIAL3 PARA SIGUIENTE PASE------*/
void esperar_prolijo2() {
cvu_prolijo2();
wa:
delay(500);
while (Serial3.available() > 0) { //esperar dato por serial3 del arduino A
charN = Serial3.read(); //leer dato tipo char
segmentacion = true;//setear en true para que se active el siguiente condicional
}
if (segmentacion == true) {
dt = data;
if (charN == 'G') { //si dato recibido es igual a D ir a siguiente funcion
charN = ' ';
delay(200);
cvu_prolijo2();//ir a siguiente funcion
} else {
goto wa;//sino hay dato volver a etiqueta
}
segmentacion = false;
}

goto wa;//volver a etiqueta

esperar_prolijo2();//volver a funcion
}
/*------CORTE V -PROLIJO#2#- CONFIGURAR SUBIR CARRO VERTICAL------*/
void cvu_prolijo2() {
//CONFIGURAR PARAMETROS DE VELOCIDAD DEL CARRO VERTICAL A SU FORMA NORMAL
carroCV.setMaxSpeed(450.0);
carroCV.setAcceleration(100.0);
carroCV.setSpeed(20);
carroCV.stop();
ss1 = digitalRead(sensor1); //leer entrada sensor 1
ss2 = digitalRead(sensor2); //leer entreda sensor 2
//CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL
SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE SUMA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1
if (t2 == 1) {
if (poscv < subir) { //si la posicion actual es menor que la variable subir
lcd.setCursor(0, 0), lcd.print("subiendo200"); //indicar en la lcd que esta subiendo CV
pasos = ((subir - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround);//poner el cv en la libreria en la posicion para regresar a 0
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
carroCV.setAcceleration(200.0);//modificar aceleracion
var1 = -4726; //poner variable en el valor 4726 previamente calibrado
var2 = 1;
var3 = 1;
cvu1_prolijo2();//ir a funcion subir
}
}
if (t2 == 0) {
if (poscv < subir + resta + 1) { //si la posicion actual es menor que la variable subir
lcd.setCursor(0, 0), lcd.print("subiendo200"); //indicar en la lcd que esta subiendo CV
pasos = (((subir + resta) - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //poner el cv en la libreria en la posicion para regresar a 0
carroCV.setCurrentPosition(pasosround);//poner el cv en la libreria en la posicion para regresar a 0
 smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
carroCV.setAcceleration(200.0);//modificar aceleracion
var1 = -4726; //poner variable en el valor 4726 previamente calibrado
var2 = 1;
var3 = 1;
cvu1_prolijo2();//ir a funcion subir
}
}
if (ss2 == 0 || ss1 == 0) { // si algunos de los sensores estan activados
lcd.setCursor(0, 0), lcd.print("placa detectada sub"); //indicar que la placa esta detectada
carroCV.setCurrentPosition(50000);//setear posicion en 50000 para mover a 0
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
//mostrar valores de los sensores
lcd.setCursor(0, 1), lcd.print("sensor1: ");
lcd.setCursor(10, 1), lcd.print(ss1);
lcd.setCursor(0, 2), lcd.print("sensor2: ");
lcd.setCursor(10, 2), lcd.print(ss2);
var1 = -(4726 - (poscv / unionFB2.datoF2) * 1000); //poner variable en el valor con la formula
var2 = 1;
delay(100);
cvu1_prolijo2();//ir a funcion para subir
}
if (ss2 == 1 && ss1 == 1) { //si ninguna de los sensores no detecto placa y la poscion actual es mayor
que subir
lcd.setCursor(0, 0), lcd.print("placa NO detectada B"); //indicar que no se ha detectado placa
carroCV.setCurrentPosition(0);//setear pos 0
smayor = 0;
cvuu_prolijo2();//ir a sig funcion de bajar
}
//CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL
SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE SUMA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1
delay(100);
if (t2 == 0) {
if (poscv > subir + resta - 1) { //si la posicion actual es mayor que la variable subir
smayor = 0; //poner variable en 0 o high para usarlo como condicional posteriormente
pasos = ((poscv - (subir + resta)) / unionFB2.datoF2) * 1000; //obtener pasos de la formula para
bajar
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(0);//poner el cv en la libreria en la posicion 0
lcd.setCursor(0, 0), lcd.print("bajando-CV"); //indicar en la lcd que esta bajando CV
cvuu_prolijo2();//ir a funcion de bajar
}
if (poscv < subir + resta + 1) { //si la posicion actual es menor que la variable subir
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
pasos = (((subir + resta) - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround); //poner el cv en la libreria en la posicion para regresar a
0
lcd.setCursor(0, 0), lcd.print("subiendo-CV"); //indicar en la lcd que esta subiendo CV
cvu1_prolijo2();//ir a funcion de subir
}
}

if (t2 == 1) { //si la posicion actual es mayor que la variable subir

 if (poscv > subir - 1) {
smayor = 0; //poner variable en 0 o high para usarlo como condicional posteriormente
pasos = ((poscv - subir) / unionFB2.datoF2) * 1000; //obtener pasos de la formula para bajar
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(0); //poner el cv en la libreria en la posicion 0
lcd.setCursor(0, 0), lcd.print("bajando-CV"); //indicar en la lcd que esta bajando CV
cvuu_prolijo2();//ir a funcion de bajar
}
if (poscv < subir + 1) { //si la posicion actual es menor que la variable subir
smayor = 1; //poner variable en 1 o high para usarlo como condicional posteriormente
pasos = ((subir - poscv) / unionFB2.datoF2) * 1000; //obtener pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround); //poner el cv en la libreria en la posicion para regresar a
0
lcd.setCursor(0, 0), lcd.print("subiendo-CV"); //indicar en la lcd que esta subiendo CV
cvu1_prolijo2();//ir a funcion de subir
}
}
cvu_prolijo2();//volver a la funcion
}
/*------CORTE V -PROLIJO#2#- SUBIR HASTA PLACA CARRO VERTICAL------*/
void cvu1_prolijo2() {
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
//a continuacion funcion para modificar la posicion y los pasos durante el recorrido para el proceso
de frenado cuando se detecta la placa
if (var3 == 1) { //si var3 esta en 1 significa que la posicion actual es menor que la de la variable subir
if (carroCV.currentPosition() < 0) { //mover posicion del cv hasta cero
if (ss2 == 1 && ss1 == 1) { //si los sensores ya no detectan placa
if (xx1 == 5 && var2 == 1) { //si xx1 est en 5 significa que ya repitio el ciclo 5 veces y var2 en 1
indica que fue detecata la placa la posicion actual es menor
var1 = carroCV.currentPosition() - 10; //restar 10 a la posicion actual para el proceso de frenado
y guardar en var 1
var2 = 0; //resetar variable en 0
xx1 = 0; //resetar variable en 0
}
if (var2 == 1) { //cuando var2 sea 1 sumar xx1
xx1++;
}
}
}
} else if (var3 == 0) { //si var3 esta en 0 significa que la posicion actual es mayor que la de la variable
subir
if (ss2 == 1 && ss1 == 1) { //si los sensores ya no detectan placa
if (xx1 == 5 && var2 == 1) { //si xx1 est en 5 significa que ya repitio el ciclo 5 veces y var2 en 1
indica que fue detecata la placa la posicion actual er menor
var1 = carroCV.currentPosition() - 10; //restar 10 a la posicion actual para el proceso de frenado
y guardar en var 1
var2 = 0; //resetar variable en 0
xx1 = 0; //resetar variable en 0
}
if (var2 == 1) { //cuando var2 sea 1 sumar xx1
xx1++;
}
}
}
 if (carroCV.currentPosition() <= var1) { //si var 1 es menor o igual que la posicion actual
delay(100);
lcd.clear();
carroCV.stop();
lcd.setCursor(0, 0), lcd.print("no se detecta sensor"); //indicar que no se detecta sensor
lcd.setCursor(0, 1), lcd.print("sensor1: ");
lcd.setCursor(10, 1), lcd.print(ss1); //mostrar valor del sensor 1
lcd.setCursor(0, 2), lcd.print("sensor2: ");
lcd.setCursor(10, 2), lcd.print(ss2); //mostrar valor del sensor 2
delay(100);
xx1 = 0;
carroCV.setAcceleration(100.0);//modificar parametro de aceleracion
var1 = 0; //resetar valor
var3 = 0; //resetar valor
cvu2_prolijo2();//ir a siguiente funcion
}
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
carroCV.moveTo(var1);//mover hacia la variable editada para el frenado suave
carroCV.run();//mover
cvu1_prolijo2();//volver a funcion
}
/*------CORTE V -PROLIJO#2#- BAJAR HASTA PLACA CARRO VERTICAL------*/
void cvuu_prolijo2() {
//si la posicion actual es mayor que la variable subir
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
fcv = digitalRead(finalCV);//leer valor del final de carrera 1
fcv1 = digitalRead(finalCV1);//leer valor del final de carrera 2
while (ss2 == 1 & ss1 == 1 & carroCV.currentPosition() < 40000 & fcv == 1) { //si los sensores estan
desactivados y la posicion es menor a 4mil y el final de carrera esta desactivada mover cv hacia abajo
ss1 = digitalRead(sensor1); //leer valor del sensor 1
ss2 = digitalRead(sensor2); //leer valor del sensor 2
fcv1 = digitalRead(finalCV1);//leer valor del final de carrera 2
fcv = digitalRead(finalCV); //leer valor del final de carrera 1
carroCV.move(5000);//mover hacia abajo el cv
carroCV.run();//mover
}
cvu2_prolijo2();//ir a siguiente funcion
}
/*------CORTE V -PROLIJO#2#- MODIFICAR VALORES DE POSICION------*/
void cvu2_prolijo2() {
lcd.clear();//limpiar lcd
// CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL
SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE RESTA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1

if (t2 == 1) {
delay(100);
lcd.setCursor(10, 2);
if (smayor == 0) { //condicional para indicar que el movimiento fue hacia abajo con smayor en 0
pasos = carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a libreria
poscv = poscv - (pasos * unionFB2.datoF2) / 1000; //modificar valor de posicion de cv
}
if (smayor == 1) { //condicional para indicar que el movimiento fue hacia arriba con smayor en 1
 pasos = - carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a
libreria+ 5000pasos constantes
poscv = poscv + (unionFB2.datoF2 * pasos) / 1000; //modificar valor de posicion de cv
}

}
if (t2 == 0) {
delay(100);
lcd.setCursor(10, 2);
if (smayor == 0) { //condicional para indicar que el movimiento fue hacia abajo con smayor en 0
pasos = carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a libreria
poscv = poscv - resta - (unionFB2.datoF2 * pasos) / 1000; //modificar valor de posicion de cv
}
if (smayor == 1) { //condicional para indicar que el movimiento fue hacia arriba con smayor en 1
pasos = - carroCV.currentPosition(); //obtener pasos de la poscion actual del carro CV en a
libreria+ 5000pasos constantes
poscv = poscv - resta + (unionFB2.datoF2 * pasos) / 1000; //modificar valor de posicion de cv
}
t2 = 1;
}
//mostrar valor en la lcd
lcd.setCursor(0, 1), lcd.print(" CV:");
lcd.setCursor(6, 1), lcd.print(poscv);
lcd.setCursor(0, 2), lcd.print(" TH:");
lcd.setCursor(6, 2), lcd.print(posth);
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
delay(200);
carroCV.stop();//para cv por seguridad
Serial3.print("M");//enviar dato a arduinoA que ya se movio el cv para continuar con el corte
Serial.println(" ");
delay(100);

huto:
delay(50);
while (Serial3.available() > 0) { //esperar serial3 para recibir dato de arduino A
charN = Serial3.read(); //obtener valor leido tipo char
segmentacion = true;
}

if (segmentacion == true) {
dt = data;
Serial.println(dt);
if (charN == 'F') { //si el valor es F seguir a la siguiente funcion
delay(100);
cvd_prolijo2();//ir a siguiente funcion
}
}
goto huto;//volver etiqueta
}
/*------CORTE V -PROLIJO#2#- CONFIGURAR BAJAR CV PARA REALIZAR EL CORTE------*/
void cvd_prolijo2() {
//configurar parametros de velocidad y aceleracion de carro CV
carroCV.setMaxSpeed(280.0);
carroCV.setAcceleration(50.0);
carroCV.setSpeed(20);
 carroCV.setCurrentPosition(0);//posicion en 0
fcv = digitalRead(finalCV);//leer sensor final de carrera 1
fcv1 = digitalRead(finalCV1);//leer sensor final de carrera 2
lcd.setCursor(0, 1), lcd.print("regresando!-CV"); //indicar en la lcd que se esta regresando cv
cvd1_prolijo2();//ir a siguiente funcion
}
/*------CORTE V -PROLIJO#2#- BAJAR CV PARA REALIZAR EL CORTE------*/
void cvd1_prolijo2() {

fcv = digitalRead(finalCV);//leer sensor final de carrera 1

fcv1 = digitalRead(finalCV1);//leer sensor final de carrera 2
while ((fcv == 1 || fcv1 == 1)) { //mover cv mientras estan desactivados
fcv = digitalRead(finalCV);//leer sensor final de carrera 1
fcv1 = digitalRead(finalCV1); //leer sensor final de carrera 2
if (fcv == 0 && fcv1 == 0) { //si los sensores se activan entonces para el cv
lcd.clear();//limpiar lcd
delay(200);
carroCV.stop();//parar cv
Serial3.print("Y");//enviar valor al arduino A para indicar que ya bajo el CV hasta el inicio
Serial.println(" ");
delay(100);
poscv = 0, t2 = 0; //resetear valores
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
loop();//volver al inicion
}
carroCV.move(5000); //mover 5mil para regresar el cv a la posicion cero por el centido invertido
carroCV.run();//mover
}
if (fcv == 0 && fcv1 == 0) {
lcd.clear();//limpiar lcd
poscv = 0;
delay(200);
carroCV.stop();//parar cv
Serial3.print("Y");//enviar valor al arduino A para indicar que ya bajo el CV hasta el inicio
Serial.println(" ");
delay(100);
poscv = 0, t2 = 0; //resetear valores
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
loop();//volver al inicion
}
loop();//volver al inicion
}
/*------CALIBRAR CV-----*/
void calibrarcv() {
//para calibrar movemos el cp al incio con el sensor final de carrera y luego le colocamos un valor de
posicion el
//carro va a ese valor y luego ingresamos la posicion que vemos y sacamos una regla de 3 con el
valor de posicion del codigo y el valor
//que estamos ingresando y esa relacion de valores lo guardamos en la memoria eeprom para que se
guarde de forma permanente!

lcd.print("CV al inicio"); //imprimir en la lcd que se debe visualizar el movimento del CV

inicp:
//configurar parametros de velocidad y aceleracion de carro CV
carroCV.setMaxSpeed(200.0);
carroCV.setAcceleration(50.0);
carroCV.setSpeed(20);
 fcv = digitalRead(finalCV);//leer sensor 1 del final de carrera del CV
fcv1 = digitalRead(finalCV1);//leer sensor 2 del final de carrera del CV

while (fcv == 1 || fcv1 == 1) { //mientras esten desactivados algunos de los 2 mover el cp y mantener
fcv = digitalRead(finalCV);//leer sensor 1 del final de carrera del CV
fcv1 = digitalRead(finalCV1);//leer sensor 2 del final de carrera del CV
if (fcv == 0 && fcv1 == 0) { //si los sensores se activan parar el carro el y luego ir a la siguiente
etiqueta para ingresar el valor
lcd.clear();//limpiar lcd
carroCV.stop();//parar CV
goto inicp;//ir a etiqueta
}
carroCV.move(5000);//mover 5milpasos para llegar al inicio
carroCV.run();//mover
}
lcd.print("CV-inicio-calib");//indicar en la lcd el inicio de la calibracion
carroCV.setCurrentPosition(2000);//como el sentido esta invertido, se coloca en la posicion y mover
a cero
delay(100);
inicp1:
//configurar parametros de velocidad y aceleracion de carro CV
carroCV.setMaxSpeed(200.0);
carroCV.setAcceleration(50.0);
carroCV.setSpeed(20);

while (carroCV.currentPosition() > 0) { //mover hasta llegar los 2mil pasos

carroCV.moveTo(0); //mover cv hasta la posicion indicada
carroCV.run();//mover
}
carroCV.stop();//parar cv para finalizar recorrido
goto inicp2; //ir a nueva etiqueta

lcd.clear();//limpar lcd
counter1 = 1;
counter = 1;
lcd.print("valor-CV(mm):");
delay(100);

inicp2:
if (keypad.getKeys()) { /*CUANDO SE PRESIONA UN BOTON DEL TECLADO MISMA
LOGICA*/
for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;
if (key == '#') { //si tecla pulsada es igual a "#" significa una ',' y procede a agregar los valores
decimales
delay(300);
counter1 = counter1 + 5;
rt1 = counter1 + 3;
lcd.setCursor(rt1, 3);
lcd.print(",");
}
 if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agregar digitos a la lcd y mover el cursor
delay(300);
counter1 = counter1 + 1;
if (counter1 > 6) {
rt1 = counter1 + 3;
} else {
rt1 = counter1 + 7;
}

lcd.setCursor(rt1, 3);
lcd.print(keypad.key[i].kchar);
lcd.setCursor(rt1 + 1, 3);
}
if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agragr digitos,sumar los digitos y agruparlos
delay(300);
if (counter1 == 2) { //unidad
char hy = keypad.key[i].kchar;
p11 = char(hy) - 48; //restar 48 para hacer casting de char a int
if (p11 < 0) { //si es menor que cero el valor será cero
p11 = 0;
}
res1 = p11;
}
if (counter1 == 3) { //decena
p22 = keypad.key[i].kchar - 48;
if (p22 < 0) {
p22 = 0;
}
res1 = (p11 * 10) + p22;
}
if (counter1 == 4) { //centena
p33 = keypad.key[i].kchar - 48;
if (p33 < 0) {
p33 = 0;
}
res1 = (p11 * 100) + (p22 * 10) + p33;
}
if (counter1 == 5) { //unidad de mil
p44 = keypad.key[i].kchar - 48;
y1 = 1;
if (p44 < 0) {
p44 = 0;
}
res1 = (p11 * 1000) + (p22 * 100) + (p33 * 10) + p44;
}
if (counter1 == 11) { //decimal
c11 = keypad.key[i].kchar - 48;
resc1 = (c11 / 10);
}

if (counter1 == 12) { //suma de decimales

c22 = keypad.key[i].kchar - 48;
resc1 = ((c11 * 10) + c22) / 100;
counter1 = 1;
}
 }
//RESULTADO FINAL DE ENTERO Y DECIMALES
resul = res1 + resc1;
calibcp = resul / 2000; //dividir valor entre los 2000 que se configuró la posicion que iba a ir el
cp en la librería de stepper
calibcp = calibcp * 1000; //multiplicar el valor por 1000 para obtener un valor no tan bajo y
guardarlo en la eeprom
lcd.setCursor(0, 4), lcd.print(resul); //mostrar resultado

if (key == '*') { //borrar digito y limpiar la lcd

if (counter1 > 6) {
rt1 = counter1 + 5;
} else {
rt1 = counter1 + 9;
}
lcd.setCursor(rt1, 3);
lcd.print(" ");
if (counter1 > 1) {
counter1 = counter1 - 1;
}
rt1 = counter1 + 6;
if (counter1 > 1) {
lcd.setCursor(rt1 + 1, 3);
} else {
lcd.setCursor(rt1 + 1, 3);
lcd.print(" ");
}
}
lcd.setCursor(0, 2);

if (key == 'K') { //cuando se pulsa la 'K' se guarda el valor en la EEPROM de manera fraccionada
y se regresa al menu
delay(300);
unionFB2.datoF2 = calibcp;//guardar valor en la varibale para fraccionar en la eeprom
EEPROM.write(60, unionFB2.datoB2[0]);
EEPROM.write(61, unionFB2.datoB2[1]);
EEPROM.write(62, unionFB2.datoB2[2]);
EEPROM.write(63, unionFB2.datoB2[3]);
delay(60);
unionFB2.datoB2[0] = EEPROM.read(60);
unionFB2.datoB2[1] = EEPROM.read(61);
unionFB2.datoB2[2] = EEPROM.read(62);
unionFB2.datoB2[3] = EEPROM.read(63);
counter = 1;
lcd.clear();//limpiar lcd
segmentacion = false;
dt = " ";
data = " ";
loop();//regresamos al inicio
}
break;
}
}
}
}
goto inicp2; //regresar a la etiqueta
calibrarcv();//regresar a la funcion
}
/*------CALIBRAR TH-----*/
void calibrarth() {
//para calibrar movemos el cp al incio con el sensor final de carrera y luego le colocamos un valor de
posicion el
//carro va a ese valor y luego ingresamos la posicion que vemos y sacamos una regla de 3 con el
valor de posicion del codigo y el valor
//que estamos ingresando y esa relacion de valores lo guardamos en la memoria eeprom para que se
guarde de forma permanente!
initv:
lcd.setCursor(0, 0), lcd.print("TH al inicio"); //imprimir en la lcd que se debe visualizar el movimento
del TH
fi = digitalRead(finalI);//leer sensor del final de carrera del TH

while ((fi == 0)) { //mientras el sensor este desactivado mover el TH

fi = digitalRead(finalI);
if (fi == 1) { //si se activa el sensor parar el carro el y luego ir a la siguiente etiqueta para ingresar el
valor
goto initv;//volver a la etiqueta para verificar
}
carroTH.move(1000); //mover 2milpasos para llegar al inicio
carroTH.run();//mover
}
carroTH.stop(); //parar TH
lcd.clear();//limpiar lcd
lcd.setCursor(0, 2), lcd.print("TH-inicio-calib"); //indicar en la lcd el inicio de la calibracion
delay(100);

initv1:
carroTH.setCurrentPosition(3000);//como el sentido esta invertido, se coloca en la posicion y mover
a cero

ff1:
if (carroTH.currentPosition() == 0) { //si llega a la posicion indicafa
carroTH.stop();//parar TH
goto ff2;//ir a nueva etiqueta
}

carroTH.moveTo(0); //mover cv hasta la posicion indicada

carroTH.run();//mover
goto ff1;
ff2:
lcd.clear();//limpiar lcd
counter1 = 1; //resetear valor
counter = 1;
lcd.setCursor(0, 1), lcd.print("valor-TV(mm):"); //indicar en la lcd para ingresar el valor

initv2:
if (keypad.getKeys()) { /*INGRESO DE TECLADO LA MISMA LOGICA*/
for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;
if (key == '#') { //si tecla pulsada es igual a "#" significa una ',' y procede a agregar los valores
decimales
delay(300);
 counter1 = counter1 + 5;
rt1 = counter1 + 3;
lcd.setCursor(rt1, 3);
lcd.print(",");
}

if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agregar digito a la lcd y mover cursor
delay(300);
counter1 = counter1 + 1;
if (counter1 > 6) {
rt1 = counter1 + 3;
} else {
rt1 = counter1 + 7;
}
lcd.setCursor(rt1, 3);
lcd.print(keypad.key[i].kchar);
lcd.setCursor(rt1 + 1, 3);
}
if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agrupar digitos ingresados(decena centena)
delay(300);
if (counter1 == 2) { //unidad
char hy = keypad.key[i].kchar; //valor leido del teclado en char
p11 = char(hy) - 48; //restar 48 para hacer casting de char a int
if (p11 < 0) {
p11 = 0;
}
res1 = p11;
}
if (counter1 == 3) { //decena
p22 = keypad.key[i].kchar - 48;
if (p22 < 0) {
p22 = 0;
}
res1 = (p11 * 10) + p22;
}
if (counter1 == 4) { //centena
p33 = keypad.key[i].kchar - 48;
if (p33 < 0) {
p33 = 0;
}
res1 = (p11 * 100) + (p22 * 10) + p33;
}
if (counter1 == 5) { //unidad de mil
p44 = keypad.key[i].kchar - 48;
y1 = 1;
if (p44 < 0) {
p44 = 0;
}
res1 = (p11 * 1000) + (p22 * 100) + (p33 * 10) + p44;
}

if (counter1 == 11) { //decimal

c11 = keypad.key[i].kchar - 48;
resc1 = (c11 / 10);
}
 if (counter1 == 12) { //suma de decimales
c22 = keypad.key[i].kchar - 48;
resc1 = ((c11 * 10) + c22) / 100;
counter1 = 1; //restablecer valor
}
}
//RESULTADO FINAL DE ENTERO Y DECIMALES
resul = res1 + resc1;
calibtv = resul / 3000; //dividir valor entre los 6500 que se configuró la posicion que iba a ir el
cp en la librería de stepper
calibtv = calibtv * 1000; //multiplicar el valor por 250 para obtener un valor no tan bajo y
guardarlo en la eeprom

if (key == '*') { //borrar digito y limpiar la lcd

if (counter1 > 6) {
rt1 = counter1 + 5;
} else {
rt1 = counter1 + 9;
}
lcd.setCursor(rt1, 3);
lcd.print(" ");
if (counter1 > 1) {
counter1 = counter1 - 1;
}
rt1 = counter1 + 6;
if (counter1 > 1) {
lcd.setCursor(rt1 + 1, 3);
} else {
lcd.setCursor(rt1 + 1, 3);
lcd.print(" ");
}
}
lcd.setCursor(0, 2);
if (key == 'K') { //cuando se pulsa la 'K' se guarda el valor en la EEPROM de manera fraccionada
y se regresa al inicio
delay(300);
unionFB3.datoF3 = calibtv;//guardar valor en la varibale para fraccionar en la eeprom
EEPROM.write(70, unionFB3.datoB3[0]);
EEPROM.write(71, unionFB3.datoB3[1]);
EEPROM.write(72, unionFB3.datoB3[2]);
EEPROM.write(73, unionFB3.datoB3[3]);
delay(60);
unionFB3.datoB3[0] = EEPROM.read(70);
unionFB3.datoB3[1] = EEPROM.read(71);
unionFB3.datoB3[2] = EEPROM.read(72);
unionFB3.datoB3[3] = EEPROM.read(73);
counter = 1;
lcd.clear();//limpiar lcd
segmentacion = false;
dt = " ";
data = " ";
loop(); //regresamos al inicio
}
break;
}
}
 }
}
goto initv2;

calibrarth();//volver a funcion
}
/*------CORTE H CONFIGURAR PASOS-----*/
void corteH() {
//configurar parametros de velocidad y aceleracion de carro CV
carroCV.setMaxSpeed(450.0);
carroCV.setAcceleration(50.0);
carroCV.setSpeed(15);

lcd.setCursor(4, 0), lcd.print("MOVIENDO-CV "); //indicar que se esta movendo cv

//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
Serial3.print("N");//enviar dato a arduinoA que ya se inicio el corte H
Serial.print(" ");

if (poscv > (res)) { //si la posicion atual es mayor al valor ingresado

pasos = ((poscv - res) / unionFB2.datoF2) * 1000; //formula para obtener los pasos
pasosround = round(pasos); //redondear pasos
lcd.setCursor(2, 2), lcd.print(" ");
lcd.setCursor(2, 2), lcd.print(pasosround); //mostrar pasos en la lcd
delay(1000);
carroCV.setCurrentPosition(0);//setear valor de posicion de cv en la libreria
corteHD();//ir a funcion para bajar cv
}

if (poscv < (res)) { //si la posicion actual es menor al valor ingresado

pasos = ((res - poscv) / unionFB2.datoF2) * 1000; //formula para obtener los pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround); //setear valor en la posicion para mover hasta 0 en la
libreria y subir cv
corteHU();//ir a funcion para subir cv
}
if (poscv == res) { //si los valores son iguales saltar funcion
cvcorte();//ir a siguiente funcion
}
corteH();//volver a funcion
}
/*------CORTE H SUBIR CV-----*/
void corteHU() {

if (carroCV.currentPosition() <= 0) {
if (t2 == 1) {
poscv = poscv + (unionFB2.datoF2 * pasos) / 1000; //formula para obtener pasos con t2=1
}
if (t2 == 0) {
poscv = poscv - resta + (unionFB2.datoF2 * pasos) / 1000; //formula para obtener pasos con t2=0
}
//mostrar valor en la lcd
lcd.setCursor(3, 1), lcd.print(" CV:");
lcd.setCursor(3, 2), lcd.print(" TH:");
lcd.setCursor(9, 2), lcd.print(posth);
lcd.setCursor(9, 1), lcd.print(poscv);
//enviar valores de posicion a la web a traves del wifi por el serial2
 Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
carroCV.stop();//para cv
cvcorte();//ir a siguiente funcion
}

carroCV.moveTo(0);//mover hasta cero en la libreria para mover hacia en la posicion en el driver

carroCV.run();//mover
corteHU();//volver a la posicion
}
/*------CORTE H BAJAR CV-----*/
void corteHD() {

carroCV.moveTo(pasosround);//mover hacia laposicion para bajar cv hasta los pasos indicados

while (carroCV.currentPosition() < pasosround) { //mientras la posicion actual no sea igual a los
pasos mover cv
carroCV.run();//mover cv
}
lcd.clear();//limpiar lcd

if (carroCV.currentPosition() >= pasosround) {

if (t2 == 1) {
poscv = poscv - (unionFB2.datoF2 * pasos) / 1000; //formula para obtener pasos con t2=1
}
if (t2 == 0) {
poscv = poscv - resta - (unionFB2.datoF2 * pasos) / 1000; //formula para obtener pasos con t2=0
}
//mostrar valor en la lcd
lcd.setCursor(3, 1), lcd.print(" CV:");
lcd.setCursor(9, 1), lcd.print(poscv);
lcd.setCursor(3, 2), lcd.print(" TH:");
lcd.setCursor(9, 2), lcd.print(posth);
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
carroCV.stop();//parar cv
cvcorte();//ir a siguiente funcion
}
corteHD();//volver a funcion
}
/*------CORTE H CONFIRMAR MOVIEMIENTO CORRECTO-----*/
void cvcorte() {
// CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL
SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE RESTA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1

if (t2 == 1) {
if (((poscv) > res - 1) && ((pos) < res + 1)) { //si la posicion cv es igual a la ingresada ir a sig funcion
carroCV.stop();
delay(100); corteHH();//ir a siguiente funcion
}
}
if (t2 == 0) {
t2 = 1;
if (((poscv + resta) > res - 1) && ((pos + resta) < res + 1)) { //si la posicion cv es igual a la ingresada ir
a sig funcion
 carroCV.stop();
delay(100); corteHH();//ir a siguiente funcion
}
}
cvcorte();//volver a funcion
}
/*------CORTE H ESPERAR CP REGRESE-----*/
void corteHH() {
lcd.setCursor(4, 0); lcd.print("ESPERANDO-CP<"); //indicar en la lcd que se esta esperando finalizar el
movimiento del cp
delay(100);
while (Serial3.available() > 0) { //cuando llegue un dato por serial3 de arduino A
charN = Serial3.read(); //leer dato tipo char
segmentacion = true;//activar el siguiente condicional
}

if (segmentacion == true) {
dt = data;
if (charN == 'M') { //si el dato recibido es igual a M ir a siguiente funcion
dt = " ";
data = " ";
delay(100);
charN = ' ';
segmentacion = false;
corteH2();//ir a siguiente funcion
}
}
corteHH();//volver a funcion
}
/*------CORTE H ACTIVAR SIERRA MOVER TH Y CORTAR-----*/
void corteH2() {
digitalWrite(releP, condicionV()); //activar releP
condicion:
if (condicionV() == LOW) { // si falla el sistema neumatico
sensorPP = digitalRead(sensorP);
if (sensorPP == HIGH || sensorPP == 1) {
lcd.clear();
delay(200);
lcd.setCursor(2, 1), lcd.print("ERROR EN SISTEMA"); //indicar error
lcd.setCursor(2, 2), lcd.print(" NEUMATICO"); //indicar error
delay(800);
goto condicion;
}

}
lcd.clear();
lcd.setCursor(3, 1), lcd.print(" CV:");
lcd.setCursor(3, 2), lcd.print(" TH:");
lcd.setCursor(9, 2), lcd.print(posth);
lcd.setCursor(9, 1), lcd.print(poscv);
//delay(4000);
lcd.setCursor(4, 3), lcd.print("SIERRA-H-ON "); //indicar que se activa la sierra
digitalWrite(releH, LOW); //activar releH

Serial2.print("r");//enviar dato por serial2 al wifi para indicar en la pagina que esta activo el releh
 if (thactivo == 1) { //variable para sacar el Th la primera vez y luego en 1
pasos = ((thir) / unionFB3.datoF3) * 1000; //formula para obtener los pasos
}
if (thactivo == 0) { //variable para sacar el Th la primera vez en 0
thactivo = 1;
pasos = ((salir) / unionFB3.datoF3) * 1000; //formula para obtener los pasos
}

lcd.setCursor(4, 0), lcd.print("MOVIENDO-TH "); //indicar en la lcd el movimiento de th

ptvrd = round(pasos); //redondear pasos
carroTH.setCurrentPosition(ptvrd);//setear posicion actual en la libreria y mover hasta cero

ff1:
if (carroTH.currentPosition() == 0) { //mover th mientras la posicion no sea igual a 0
carroTH.stop();//parar th
goto ff2;//ir a siguiente etiqueta
}

carroTH.moveTo(0);//mover th hasta cero

carroTH.run();//mover
goto ff1;//volver la etiqueta

ff2:
posth = posth + (unionFB3.datoF3 * pasos) / 1000; //modificar posicion de th

delay(100);
Serial3.print("C");//enviar dato a arduino A por serial3 que ya se saco el th y se encendio la sierra
Serial.println(" ");
delay(100);

lcd.setCursor(4, 0); lcd.print("ESPERANDO-CP>"); //indicar en la lcd que se espera el moviemineto de

cp

ok2:
//esperar dato por serial
delay(100);
while (Serial3.available() > 0) { //cuando reciba dato por serial
charN = Serial3.read(); //guardar dato en un char
segmentacion = true;//activar condicional posteriol
}

if (segmentacion == true) {
dt = data;
if (charN == 'B') { //si el dato recibido es B entonces apagar releH e ir a siguiente funcion
dt = " ";
data = " ";
delay(100);
digitalWrite(releH, HIGH); //apagar releH
Serial2.print("s");//enviar dato a la pagina que el rele esta desactivado
lcd.setCursor(4, 3), lcd.print("SIERRA-H-OFF"); //indicar en la lcd que el rele esta desactivado
charN = ' ';
segmentacion = false;
corteH3();//ir a siguiente funcion
}
segmentacion = false;
}
goto ok2;//volver a etiqueta
 corteH2();
}
/*------CORTE H REGRESAR TH-----*/
void corteH3() {

lcd.setCursor(4, 0), lcd.print("REGRESANDO-TH"); //indicar en la lcd que se esta regresando th

pasos = ((thir) / unionFB3.datoF3) * 1000; //obtener pasos
ptvrd = round(pasos); //redondear pasos
carroTH.setCurrentPosition(0);//setear posicion del th
ff1:
if (carroTH.currentPosition() == ptvrd) { //si la posicion actual no es igual a los pasos mover th si es
igual parar th
carroTH.stop();//parar th
goto ff2;//ir a siguiente etiqueta
}

carroTH.moveTo(ptvrd);//mover th a la posicion
carroTH.run();//mover
goto ff1;

ff2:
posth = posth - (unionFB3.datoF3 * pasos) / 1000; //modificar variable de posicion
lcd.setCursor(12, 2), lcd.print(posth); //imprimir variable de poscion
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
lcd.clear(); //limpiar lcd
delay(100);
Serial3.print("D");//enviar dato que ya se regreso el th
Serial.println(" ");
delay(100);
recordar = poscv;
loop();//ir al incio
}
/*------CORTE H -PROLIJO- CONFIGURAR PASOS-----*/
void corteH_prolijo() {
//configurar parametros de velocidad y aceleracion de carro CV
carroCV.setMaxSpeed(450.0);
carroCV.setAcceleration(50.0);
carroCV.setSpeed(15);
lcd.setCursor(4, 0), lcd.print("MOVIENDO-CV "); //indicar que se esta movendo cv
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
Serial3.print("Y");//enviar dato a arduinoA que ya se inicio el corte H prolijo
Serial.print(" ");

if (poscv > (res)) { //si la posicion atual es mayor al valor ingresado

pasos = ((poscv - res) / unionFB2.datoF2) * 1000; //formula para obtener los pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(0); //setear valor de posicion de cv en la libreria
corteHD_prolijo();//ir a funcion para bajar cv
}

if (poscv < (res)) { //si la posicion actual es menor al valor ingresado

pasos = ((res - poscv) / unionFB2.datoF2) * 1000; //formula para obtener los pasos
pasosround = round(pasos); //redondear pasos
carroCV.setCurrentPosition(pasosround);//setear valor en la posicion para mover hasta 0 en la
libreria y subir cv
 corteHU_prolijo();//ir a funcion para subir cv
}
if (poscv == res) { //si los valores son iguales saltar funcion
cvcorte_prolijo(); //ir a siguiente funcion
}
corteH_prolijo(); //volver a funcion
}
/*------CORTE H -PROLIJO- SUBIR CV-----*/
void corteHU_prolijo() {

if (carroCV.currentPosition() <= 0) { //cuando sea igual o menor que 0

if (t2 == 1) {
poscv = poscv + (unionFB2.datoF2 * pasos) / 1000; //formula para obtener pasos con t2=1
}
if (t2 == 0) {
poscv = poscv - resta + (unionFB2.datoF2 * pasos) / 1000; //formula para obtener pasos con t2=0
}
//mostrar valor en la lcd
lcd.setCursor(3, 1), lcd.print(" CV:");
lcd.setCursor(3, 2), lcd.print(" TH:");
lcd.setCursor(9, 2), lcd.print(posth);
lcd.setCursor(9, 1), lcd.print(poscv);
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
carroCV.stop();//para cv
cvcorte_prolijo();//ir a siguiente funcion
}

carroCV.moveTo(0); //mover hasta cero en la libreria para mover hacia en la posicion en el driver
carroCV.run();//mover
corteHU_prolijo();//volver a la posicion
}
/*------CORTE H -PROLIJO- BAJAR CV-----*/
void corteHD_prolijo() {

if (carroCV.currentPosition() >= pasosround) { //cuando la posicion actual sea mayor o igual a los
pasos obtenidos
if (t2 == 1) {
poscv = poscv - (unionFB2.datoF2 * pasos) / 1000; //formula para obtener pasos con t2=1
}
if (t2 == 0) {
poscv = poscv - resta - (unionFB2.datoF2 * pasos) / 1000; //formula para obtener pasos con t2=0
}
//mostrar valores en lcd
lcd.setCursor(3, 1), lcd.print(" CV:");
lcd.setCursor(9, 1), lcd.print(poscv);
lcd.setCursor(3, 2), lcd.print(" TH:");
lcd.setCursor(9, 2), lcd.print(posth);
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
carroCV.stop();
cvcorte_prolijo();
}
carroCV.moveTo(pasosround); //mover hacia laposicion para bajar cv hasta los pasos indicados
carroCV.run();//mover
corteHD_prolijo();//volver a funcion
}
/*------CORTE H -PROLIJO- CONFIRMAR MOVIEMIENTO CORRECTO-----*/
void cvcorte_prolijo() {
// CUANDO T2=0 SIGNIFICA QUE ES EL PRIMER MOVIMIENTO LUEGO DE HABER ALIMENTADO EL
SISTEMA
// POR LO TANTO E LE SUMA UN VALOR PREVIAMENTE ESTABLECIDO PERO SOLO LA PRIMERA VEZ
// LUEGO DE ESO SE PONE T2 EN 1 Y NO SE LE RESTA EL VALOR POR ESO ESTAN LAS 2 CONDICIONES
CON T2 EN 0 Y 1
if (t2 == 1) {
if (((poscv) > res - 1) && ((pos) < res + 1)) { //si la posicion cv es igual a la ingresada ir a sig funcion
carroCV.stop();
delay(100); corteHH_prolijo(); //ir a siguiente funcion
}
}
if (t2 == 0) {
t2 = 1;
if (((poscv + resta) > res - 1) && ((pos + resta) < res + 1)) { //si la posicion cv es igual a la ingresada ir
a sig funcion
carroCV.stop();
delay(100); corteHH_prolijo();//ir a siguiente funcion
}
}
cvcorte_prolijo();//volver a funcion
}
/*------CORTE H -PROLIJO- ESPERAR CP REGRESE-----*/
void corteHH_prolijo() {

lcd.setCursor(4, 0); lcd.print("ESPERANDO-CP<"); //indicar en la lcd que se esta esperando finalizar el

movimiento del cp
delay(100);
while (Serial3.available() > 0) { //cuando llegue un dato por serial3 de arduino A
charN = Serial3.read(); //leer dato tipo char
segmentacion = true;//activar el siguiente condicional
}

if (segmentacion == true) {
dt = data;
if (charN == 'I') { //si el dato recibido es igual a I ir a siguiente funcion
dt = " ";
data = " ";
delay(100);
charN = ' ';
segmentacion = false;
corteH2_prolijo(); //ir a siguiente funcion
}
}
corteHH_prolijo();//volver a funcion
}
/*------CORTE H -PROLIJO- ACTIVAR SIERRA MOVER TH Y CORTAR-----*/
void corteH2_prolijo() {
digitalWrite(releP, condicionV()); //activar releP
condicion:
if (condicionV() == LOW) { // si falla el sistema neumatico
sensorPP = digitalRead(sensorP);
if (sensorPP == HIGH || sensorPP == 1) {
lcd.clear();
delay(200);
lcd.setCursor(2, 1), lcd.print("ERROR EN SISTEMA"); //indicar error
 lcd.setCursor(2, 2), lcd.print(" NEUMATICO"); //indicar error
delay(800);
goto condicion;
}

}
lcd.clear();
lcd.setCursor(3, 1), lcd.print(" CV:");
lcd.setCursor(3, 2), lcd.print(" TH:");
lcd.setCursor(9, 2), lcd.print(posth);
lcd.setCursor(9, 1), lcd.print(poscv);
//delay(4000);
lcd.setCursor(4, 3), lcd.print("SIERRA-H-ON "); //indicar que se activa la sierra
digitalWrite(releH, LOW); //activar releH
Serial2.print("r");//enviar dato por serial2 al wifi para indicar en la pagina que esta activo el releh

if (thactivo == 1) { //variable para sacar el Th la primera vez y luego en 1

pasos = ((thir - prolijoh) / unionFB3.datoF3) * 1000; //formula para obtener los pasos
}
if (thactivo == 0) { //variable para sacar el Th la primera vez en 0
thactivo = 1;
pasos = ((salir - prolijoh) / unionFB3.datoF3) * 1000; //formula para obtener los pasos
}

lcd.setCursor(4, 0), lcd.print("MOVIENDO-TH "); //indicar en la lcd el movimiento de th

ptvrd = round(pasos); //redondear pasos
carroTH.setCurrentPosition(ptvrd);//setear posicion actual en la libreria y mover hasta cero

ff1:
if (carroTH.currentPosition() == 0) { //mover th mientras la posicion no sea igual a 0
carroTH.stop();//parar th
goto ff2;//ir a siguiente etiqueta
}
carroTH.moveTo(0);//mover th hasta cero
carroTH.run();//mover
goto ff1;//volver la etiqueta

ff2:
posth = posth + (unionFB3.datoF3 * pasos) / 1000; //modificar posicion de th

delay(100);
Serial3.print("R");//enviar dato a arduino A por serial3 que ya se saco el th y se encendio la sierra
Serial.println(" ");
delay(100);

lcd.setCursor(4, 0); lcd.print("ESPERANDO-CP>"); //indicar en la lcd que se espera el moviemineto de

cp
ok2:
//esperar dato por serial
delay(100);
while (Serial3.available() > 0) { //cuando reciba dato por serial
charN = Serial3.read(); //guardar dato en un char
segmentacion = true;//activar condicional posteriol
}

if (segmentacion == true) {
dt = data;
 if (charN == 'Q') { //si el dato recibido es B entonces apagar releH e ir a siguiente funcion
dt = " ";
data = " ";
delay(100);
digitalWrite(releH, HIGH); //apagar releH
Serial2.print("s");//enviar dato a la pagina que el rele esta desactivado
lcd.setCursor(4, 3), lcd.print("SIERRA-H-OFF"); //indicar en la lcd que el rele esta desactivado
charN = ' ';
segmentacion = false;
corteH3_prolijo();//ir a siguiente funcion
}
segmentacion = false;
}

goto ok2; //volver a etiqueta

corteH2_prolijo();
}
/*------CORTE H -PROLIJO- REGRESAR TH-----*/
void corteH3_prolijo() {

lcd.setCursor(4, 0), lcd.print("REGRESANDO-TH"); //indicar en la lcd que se esta regresando th

pasos = ((thir - prolijoh) / unionFB3.datoF3) * 1000; //obtener pasos
ptvrd = round(pasos); //redondear pasos
carroTH.setCurrentPosition(0);//setear posicion del th

ff1:
if (carroTH.currentPosition() == ptvrd) { //si la posicion actual no es igual a los pasos mover th si es
igual parar th
carroTH.stop();//parar th
goto ff2;//ir a siguiente etiqueta
}
carroTH.moveTo(ptvrd);//mover th a la posicion
carroTH.run();//mover
goto ff1;
ff2:
posth = posth - (unionFB3.datoF3 * pasos) / 1000; //modificar variable de posicion
lcd.setCursor(12, 2), lcd.print(posth); //imprimir variable de poscion
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
lcd.clear();//limpiar lcd
delay(100);
Serial3.print("F");//enviar dato que ya se regreso el th
Serial.println(" ");
delay(500);
cvcorte_prolijo2();//ir al Siguiente pase
}
/*------CORTE H -PROLIJO#2#- CONFIRMAR SIGUENTE PASE-----*/
void cvcorte_prolijo2() {
Serial3.print("J");//enviar dato al arduino A para continuar con el siguiente pase
Serial.print(" ");
delay(100);
corteHH_prolijo2();//ir a siguiente funcion
}
/*------CORTE H -PROLIJO#2#- ESPERAR CP REGRESE-----*/
void corteHH_prolijo2() {
 lcd.setCursor(4, 0); lcd.print("ESPERANDO-CP<"); //indicar en la lcd que se esta esperando finalizar el
movimiento del cp
delay(100);
while (Serial3.available() > 0) { //cuando llegue un dato por serial3 de arduino A
charN = Serial3.read(); //leer dato tipo char
segmentacion = true;//activar el siguiente condicional
}

if (segmentacion == true) {
dt = data;
if (charN == 'L') { //si el dato recibido es igual a L ir a siguiente funcion
Serial.println("ok");
dt = " ";
data = " ";
delay(100);
charN = ' ';
segmentacion = false;
corteH2_prolijo2();//ir a siguiente funcion
}
}
corteHH_prolijo2();//volver a funcion
}
/*------CORTE H -PROLIJO#2#- ACTIVAR SIERRA MOVER TH Y CORTAR-----*/
void corteH2_prolijo2() {
digitalWrite(releP, condicionV()); //activar releP
condicion:
if (condicionV() == LOW) {
sensorPP = digitalRead(sensorP);
if (sensorPP == HIGH || sensorPP == 1) { // si falla el sistema neumatico
lcd.clear();
delay(200);
lcd.setCursor(2, 1), lcd.print("ERROR EN SISTEMA"); //indicar error ERROR EN SISTEMA
lcd.setCursor(2, 2), lcd.print(" NEUMATICO"); //indicar error ERROR EN SISTEMA
delay(800);
goto condicion;
}

}
lcd.clear();
lcd.setCursor(3, 1), lcd.print(" CV:");
lcd.setCursor(3, 2), lcd.print(" TH:");
lcd.setCursor(9, 2), lcd.print(posth);
lcd.setCursor(9, 1), lcd.print(poscv);
//delay(4000);
lcd.setCursor(4, 3), lcd.print("SIERRA-H-ON "); //indicar que se activa la sierra
digitalWrite(releH, LOW); //activar releH
Serial2.print("r");//enviar dato por serial2 al wifi para indicar en la pagina que esta activo el releh
pasos = ((thir) / unionFB3.datoF3) * 1000; //obtener pasos

lcd.setCursor(4, 0), lcd.print("MOVIENDO-TH "); //indicar en la lcd el movimiento de th

ptvrd = round(pasos); //redondear pasos
carroTH.setCurrentPosition(ptvrd);//setear posicion actual en la libreria y mover hasta cero

ff1:
if (carroTH.currentPosition() == 0) { //mover th mientras la posicion no sea igual a 0
carroTH.stop();//parar th
goto ff2;//ir a siguiente etiqueta
 }

carroTH.moveTo(0);//mover th hasta cero

carroTH.run();//mover
goto ff1;//volver la etiqueta

ff2:
posth = posth + (unionFB3.datoF3 * pasos) / 1000; //modificar posicion de th

delay(100);
Serial3.print("S");//enviar dato a arduino A por serial3 que ya se saco el th y se encendio la sierra
Serial.println(" ");
delay(100);

lcd.setCursor(4, 0); lcd.print("ESPERANDO-CP>"); //indicar en la lcd que se espera el moviemineto de

cp

ok2:
//esperar dato por serial
delay(100);
while (Serial3.available() > 0) { //cuando reciba dato por serial
charN = Serial3.read(); //guardar dato en un char
segmentacion = true;//activar condicional posteriol
}

if (segmentacion == true) {
dt = data;
if (charN == 'P') { //si el dato recibido es P entonces apagar releH e ir a siguiente funcion
dt = " ";
data = " ";
delay(100);
digitalWrite(releH, HIGH); //apagar releH
Serial2.print("s");//enviar dato a la pagina que el rele esta desactivado
lcd.setCursor(4, 3), lcd.print("SIERRA-H-OFF"); //indicar en la lcd que el rele esta desactivado
charN = ' ';
segmentacion = false;
corteH3_prolijo2();//ir a siguiente funcion
}
segmentacion = false;
}
goto ok2;//volver a etiqueta
corteH2_prolijo2();
}
/*------CORTE H -PROLIJO#2#- REGRESAR TH FIN DEL CORTE-----*/
void corteH3_prolijo2() {

lcd.setCursor(4, 0), lcd.print("REGRESANDO-TH"); //indicar en la lcd que se esta regresando th

pasos = ((thir) / unionFB3.datoF3) * 1000; //obtener pasos
ptvrd = round(pasos); //redondear pasos
carroTH.setCurrentPosition(0);//setear posicion del th

ff1:
if (carroTH.currentPosition() == ptvrd) { //si la posicion actual no es igual a los pasos mover th si es
igual parar th
carroTH.stop();//parar th
goto ff2;//ir a siguiente etiqueta
}
 carroTH.moveTo(ptvrd);//mover th a la posicion
carroTH.run();//mover
goto ff1;
ff2:
posth = posth - (unionFB3.datoF3 * pasos) / 1000; //modificar variable de posicion
lcd.setCursor(12, 2), lcd.print(posth); //imprimir variable de poscion
//enviar valores de posicion a la web a traves del wifi por el serial2
Serial2.print(":"), Serial2.print(poscv), Serial2.print(":"), Serial2.print(posth), Serial2.print(":");
lcd.clear();//limpiar lcd
delay(100);
Serial3.print("X");//enviar dato que ya se regreso el th
Serial.println(" ");
delay(100);
recordar = poscv;
loop();//ir al incio

}
/*------PROLIJO H-----*/
void thprolijo() {
//ESTA CALIBRACION ES PARA EDITAR EL VALOR DE Prolijo TH
lcd.setCursor(0, 0);
lcd.print("actualmente:");
lcd.print(prolijoh);//mostrar valor actual del valor
lcd.setCursor(0, 1);
lcd.print("PROLIJO H(mm):");
if (keypad.getKeys()) { /*INGRESO DE TECLADO LA MISMA LOGICA*/
for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;
if (key == 'C') { //volver al loop
delay(300);
lcd.clear();
loop();
}
if (key == '#') { //ingresar coma
delay(300);
counter1 = counter1 + 5;
rt1 = counter1 + 4;
lcd.setCursor(rt1, 2);
lcd.print(",");
}

if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agregar digito a la lcd y mover cursor
lcd.setCursor(0, 1);
counter1 = counter1 + 1;
if (counter1 > 6) {
rt1 = counter1 + 4;
} else {
rt1 = counter1 + 8;
}
lcd.setCursor(rt1, 2);
lcd.print(keypad.key[i].kchar);
lcd.setCursor(rt1 + 1, 2);
 }
if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agrupar digitos ingresados(decena centena)
delay(300);
if (counter1 == 2) { //unidad
char hy = keypad.key[i].kchar;
p11 = char(hy) - 48;
if (p11 < 0) {
p11 = 0;
}
res1 = p11;
}
if (counter1 == 3) { //decena
p22 = keypad.key[i].kchar - 48;
if (p22 < 0) {
p22 = 0;
}
res1 = (p11 * 10) + p22;
}
if (counter1 == 4) { //centena
p33 = keypad.key[i].kchar - 48;
if (p33 < 0) {
p33 = 0;
}
counter1 = 1;
y11 = 1;
res1 = (p11 * 100) + (p22 * 10) + p33;
}
if (counter1 > 7) { //decimal
c11 = keypad.key[i].kchar - 48;
resc1 = (c11 / 10);
counter1 = 1;
}

calib4 = res1 + resc1; //resultado total

}

if (key == 'K') { //cuando el digito del teclado es 'K' guarda el nuevo valor ingreado fraccionado
en la nueva eeprom
delay(300);
unionFB7.datoF7 = calib4;//guardar valor float en el arreglo de la eeprom
EEPROM.write(100, unionFB7.datoB7[0]);
EEPROM.write(101, unionFB7.datoB7[1]);
EEPROM.write(102, unionFB7.datoB7[2]);
EEPROM.write(103, unionFB7.datoB7[3]);
delay(60);
//leer datos en de la eeprom y guardar en la variable
unionFB7.datoB7[0] = EEPROM.read(100);
unionFB7.datoB7[1] = EEPROM.read(101);
unionFB7.datoB7[2] = EEPROM.read(102);
unionFB7.datoB7[3] = EEPROM.read(103);
counter = 1;
prolijoh = unionFB7.datoF7; //guardar valor leido en varibale
lcd.clear();//limpiar lcd
loop();//volver al inicio
}
 if (key == '*') { //borrar un digito y limpiar lcd
if (counter1 > 6) {
rt = counter1 + 5;
lcd.setCursor(rt, 2);
lcd.print(" ");
counter1 = counter1 - 3;
} else {
rt = counter1 + 8;
lcd.setCursor(rt, 2);
lcd.print(" ");
}
if (counter1 > 1) {
counter1 = counter1 - 1;
} else {
lcd.setCursor(rt + 1, 2);
lcd.print(" ");
}
}
break;
}
}
}
}
thprolijo();//volver a la funcion
}
/*------AJUSTAR CV-----*/
void ajustarcv() {
//agregar valor de una variable sin necesidad de calibrar algun motor simplemente se agrega el
valor y este se guarda en la eeprom
lcd.setCursor(0, 0);
lcd.print("actualmente:");
lcd.print(resta);//mostrar valor actual del valor
lcd.setCursor(0, 1);
lcd.print("AJUSTAR CV(-mm):");

if (keypad.getKeys()) { /*INGRESO DE TECLADO LA MISMA LOGICA*/

for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;
if (key == 'C') { //volver al inicio
delay(300);
lcd.clear();
loop();
}
if (key == '#') { //agregar coma
delay(300);
counter1 = counter1 + 5;
rt1 = counter1 + 4;
lcd.setCursor(rt1, 2);
lcd.print(",");
}

if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agregar digito a la lcd y mover cursor
lcd.setCursor(0, 1);
 counter1 = counter1 + 1;
if (counter1 > 6) {
rt1 = counter1 + 4;
} else {
rt1 = counter1 + 8;
}
lcd.setCursor(rt1, 2);
lcd.print(keypad.key[i].kchar);
lcd.setCursor(rt1 + 1, 2);
}
if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agrupar digitos ingresados(decena centena)
delay(300);
if (counter1 == 2) { //unidad
char hy = keypad.key[i].kchar; //valor leido del teclado en char
p11 = char(hy) - 48; //restar 48 de casting de char a int
if (p11 < 0) {
p11 = 0;
}
res1 = p11;
}
if (counter1 == 3) { //decena
p22 = keypad.key[i].kchar - 48;
if (p22 < 0) {
p22 = 0;
}
res1 = (p11 * 10) + p22;
}
if (counter1 == 4) { //centena
p33 = keypad.key[i].kchar - 48;
if (p33 < 0) {
p33 = 0;
}
counter1 = 1;
y11 = 1;
res1 = (p11 * 100) + (p22 * 10) + p33;
}
if (counter1 > 7) { //decimal
c11 = keypad.key[i].kchar - 48;
resc1 = (c11 / 10);
counter1 = 1;
}
calib4 = res1 + resc1; //suma total de valor entero y decimal
}
if (key == 'K') { //cuando el digito del teclado es 'K' guarda el nuevo valor ingreado fraccionado
en la nueva eeprom
delay(300);
unionFB4.datoF4 = calib4;
EEPROM.write(80, unionFB4.datoB4[0]);
EEPROM.write(81, unionFB4.datoB4[1]);
EEPROM.write(82, unionFB4.datoB4[2]);
EEPROM.write(83, unionFB4.datoB4[3]);
delay(60);
//leer datos en de la eeprom y guardar en la variable
unionFB4.datoB4[0] = EEPROM.read(80);
unionFB4.datoB4[1] = EEPROM.read(81);
unionFB4.datoB4[2] = EEPROM.read(82);
 unionFB4.datoB4[3] = EEPROM.read(83);
counter = 1;
resta = -unionFB4.datoF4; //guardar valor leido en varibale
lcd.clear();//limpiar lcd
loop();//volver al inicio
}

if (key == '*') { //borrar un digito y limpiar lcd

if (counter1 > 6) {
rt = counter1 + 5;
lcd.setCursor(rt, 2);
lcd.print(" ");
counter1 = counter1 - 3;
} else {
rt = counter1 + 8;
lcd.setCursor(rt, 2);
lcd.print(" ");
}
if (counter1 > 1) {
counter1 = counter1 - 1;
} else {
lcd.setCursor(rt + 1, 2);
lcd.print(" ");
}
}
break;
}
}
}
}
ajustarcv();//volver a la funcion
}
/*------AJUSTAR TH SALIR-----*/
void thsalir() {
//agregar valor de una variable sin necesidad de calibrar algun motor simplemente se agrega el
valor y este se guarda en la eeprom
lcd.setCursor(0, 0);
lcd.print("actualmente:");
lcd.print(unionFB5.datoF5);//mostrar valor actual del valor
lcd.setCursor(0, 1);
lcd.print("AJUSTAR SALIR(mm):");

if (keypad.getKeys()) { /*INGRESO DE TECLADO LA MISMA LOGICA*/

for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;
if (key == 'C') { //volver al inicio
delay(300);
lcd.clear();
menu2();
}
if (key == '#') { //agregar coma
delay(300);
counter1 = counter1 + 5;
rt1 = counter1 + 4;
 lcd.setCursor(rt1, 2);
lcd.print(",");
}

if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agregar digito a la lcd y mover cursor
lcd.setCursor(0, 1);
counter1 = counter1 + 1;
if (counter1 > 6) {
rt1 = counter1 + 4;
} else {
rt1 = counter1 + 8;
}
lcd.setCursor(rt1, 2);
lcd.print(keypad.key[i].kchar);
lcd.setCursor(rt1 + 1, 2);
}
if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agrupar digitos ingresados(decena centena)
delay(300);
if (counter1 == 2) { //unidad
char hy = keypad.key[i].kchar;
p11 = char(hy) - 48;
if (p11 < 0) {
p11 = 0;
}
res1 = p11;
}
if (counter1 == 3) { //decena
p22 = keypad.key[i].kchar - 48;
if (p22 < 0) {
p22 = 0;
}
res1 = (p11 * 10) + p22;
}
if (counter1 == 4) { //centena
p33 = keypad.key[i].kchar - 48;
if (p33 < 0) {
p33 = 0;
}
counter1 = 1;
y11 = 1;
res1 = (p11 * 100) + (p22 * 10) + p33;
}
if (counter1 > 7) { //decimal
c11 = keypad.key[i].kchar - 48;
resc1 = (c11 / 10);
}
salir = res1 + resc1; //suma total de valor entero y decimal
}
if (key == 'K') { //cuando el digito del teclado es 'K' guarda el nuevo valor ingreado fraccionado
en la nueva eeprom
delay(300);
unionFB5.datoF5 = salir;//guardar valor en la varibale para fraccionar en la eeprom
EEPROM.write(90, unionFB5.datoB5[0]);
EEPROM.write(91, unionFB5.datoB5[1]);
EEPROM.write(92, unionFB5.datoB5[2]);
 EEPROM.write(93, unionFB5.datoB5[3]);
delay(60);
//leer datos en de la eeprom y guardar en la variable
unionFB5.datoB5[0] = EEPROM.read(90);
unionFB5.datoB5[1] = EEPROM.read(91);
unionFB5.datoB5[2] = EEPROM.read(92);
unionFB5.datoB5[3] = EEPROM.read(93);
counter = 1;
salir = unionFB5.datoF5; //guardar valor leido en varibale
thir = salir - 22; //calibrar otra variable dependiente de la modificada
lcd.clear();//limpiar lcd
counter1 = 1;
menu2(); //volver al menu
}
if (key == '*') { //borrar un digito y limpiar lcd
if (counter1 > 6) {
rt = counter1 + 5;
lcd.setCursor(rt, 2);
lcd.print(" ");
counter1 = counter1 - 3;
} else {
rt = counter1 + 8;
lcd.setCursor(rt, 2);
lcd.print(" ");
}
if (counter1 > 1) {
counter1 = counter1 - 1;
} else {
lcd.setCursor(rt + 1, 2);
lcd.print(" ");
}
}
break;
}
}
}
}
thsalir();//volver a la funcion
}
/*------AJUSTAR TH AJUSTE 0-----*/
void tvajuste0() {
//agregar valor de una variable sin necesidad de calibrar algun motor simplemente se agrega el
valor y este se guarda en la eeprom
lcd.setCursor(0, 0);
lcd.print("actualmente:");
lcd.print(unionFB6.datoF6);//mostrar valor actual
lcd.setCursor(0, 1);
lcd.print("AJUSTAR 0(mm):");

if (keypad.getKeys()) { /*INGRESO DE TECLADO LA MISMA LOGICA*/

for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;
if (key == 'C') { //volver al menu
delay(300);
 lcd.clear();
menu2();
}
if (key == '#') { //agregar coma
delay(300);
counter1 = counter1 + 5;
rt1 = counter1 + 4;
lcd.setCursor(rt1, 2);
lcd.print(",");
}

if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agregar digito a la lcd y mover cursor
lcd.setCursor(0, 1);
counter1 = counter1 + 1;
if (counter1 > 6) {
rt1 = counter1 + 4;
} else {
rt1 = counter1 + 8;
}
lcd.setCursor(rt1, 2);
lcd.print(keypad.key[i].kchar);
lcd.setCursor(rt1 + 1, 2);
}
if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agrupar digitos ingresados(decena centena)
delay(300);
if (counter1 == 2) { //unidad
char hy = keypad.key[i].kchar;
p11 = char(hy) - 48;
if (p11 < 0) {
p11 = 0;
}
res1 = p11;
}
if (counter1 == 3) { //decena
p22 = keypad.key[i].kchar - 48;
if (p22 < 0) {
p22 = 0;
}
res1 = (p11 * 10) + p22;
}
if (counter1 == 4) { //centena
p33 = keypad.key[i].kchar - 48;
if (p33 < 0) {
p33 = 0;
}
counter1 = 1;
y11 = 1;
res1 = (p11 * 100) + (p22 * 10) + p33;
}
if (counter1 > 7) { //decimal
c11 = keypad.key[i].kchar - 48;
resc1 = (c11 / 10);
}
cero = res1 + resc1; //suma total de valor entero y decimal
}
 if (key == 'K') { //cuando el digito del teclado es 'K' guarda el nuevo valor ingreado fraccionado
en la nueva eeprom
delay(300);
unionFB6.datoF6 = cero;//guardar valor en el arreglo para guardar en la eeprom
EEPROM.write(94, unionFB6.datoB6[0]);
EEPROM.write(95, unionFB6.datoB6[1]);
EEPROM.write(96, unionFB6.datoB6[2]);
EEPROM.write(97, unionFB6.datoB6[3]);
delay(60);
//leer datos en de la eeprom y guardar en la variable
unionFB6.datoB6[0] = EEPROM.read(94);
unionFB6.datoB6[1] = EEPROM.read(95);
unionFB6.datoB6[2] = EEPROM.read(96);
unionFB6.datoB6[3] = EEPROM.read(97);
counter = 1;
cero = unionFB6.datoF6; //guardar valor leido en varibale
lcd.clear();//limpiar lcd
counter1 = 1;
menu2();//volver al menu
}

if (key == '*') { //borrar un digito y limpiar lcd

if (counter1 > 6) {
rt = counter1 + 5;
lcd.setCursor(rt, 2);
lcd.print(" ");
counter1 = counter1 - 3;
} else {
rt = counter1 + 8;
lcd.setCursor(rt, 2);
lcd.print(" ");
}
if (counter1 > 1) {
counter1 = counter1 - 1;
} else {
lcd.setCursor(rt + 1, 2);
lcd.print(" ");
}
}
break;
}
}
}
}

tvajuste0();//volver a funcion
}
/*------AJUSTAR PROFUNDIDAD TH-----*/
void profth() {
if (ptv1 == 1) { //si la variable es 1 la profundidad th esta activada
lcd.setCursor(3, 3);
lcd.print("PROF. TH ON ");//mostrar lcd que esta activada
} else if (ptv1 == 0) { //sino esta desactivada
lcd.setCursor(3, 3);
lcd.print("PROF. TH OFF");//mostrar lcd que esta desactivada
}
 //agregar valor de una variable sin necesidad de calibrar algun motor simplemente se agrega el
valor y este se guarda en la eeprom
lcd.setCursor(0, 0);
lcd.print("actualmente:");
lcd.print(profun);//mostrar valor actual
lcd.setCursor(0, 1);
lcd.print("PROFUNDIDAD(+/-mm):");

if (keypad.getKeys()) { /*INGRESO DE TECLADO LA MISMA LOGICA*/

for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;
if (key == 'C') { //volver al menu
delay(300);
lcd.clear();
menu2();
}
if (key == 'A') { //cambiar de estado la variable de activacion de profundidad
delay(100);
if (ptv1 == 1) {
ptv1 = 0;
profth();
}
if (ptv1 == 0) {
ptv1 = 1;
profth();
}
}
if (key == 'B') { //Cambiar de valor la variable negativo en 0 o 1
if (negativo == 0) {
lcd.setCursor(8, 2);
lcd.print("-");
negativo = 1;
profth();
}
if (negativo == 1) {
lcd.setCursor(8, 2);
lcd.print(" ");
negativo = 0;
profth();
}
}
if (key == '#') { //agregar coma
delay(300);
counter1 = counter1 + 5;
rt1 = counter1 + 4;
lcd.setCursor(rt1, 2);
lcd.print(",");
}

if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agregar digito a la lcd y mover cursor
lcd.setCursor(0, 1);
counter1 = counter1 + 1;
if (counter1 > 6) {
 rt1 = counter1 + 4;
} else {
rt1 = counter1 + 8;
}
lcd.setCursor(rt1, 2);
lcd.print(keypad.key[i].kchar);
lcd.setCursor(rt1 + 1, 2);
}
if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agrupar digitos ingresados(decena centena)
delay(300);
if (counter1 == 2) { //unidad
char hy = keypad.key[i].kchar;
p11 = char(hy) - 48;
if (p11 < 0) {
p11 = 0;
}
res1 = p11;
}
if (counter1 == 3) { //decena
p22 = keypad.key[i].kchar - 48;
if (p22 < 0) {
p22 = 0;
}
res1 = (p11 * 10) + p22;
}
if (counter1 == 4) { //centena
p33 = keypad.key[i].kchar - 48;
if (p33 < 0) {
p33 = 0;
}
counter1 = 1;
y11 = 1;
res1 = (p11 * 100) + (p22 * 10) + p33;
}
if (counter1 > 7) { //decimal
c11 = keypad.key[i].kchar - 48;
resc1 = (c11 / 10);
}
profun = res1 + resc1; //suma total de valor entero y decimal
}

if (key == 'K') { //cuando el digito del teclado es 'K' guarda el nuevo valor ingreado
delay(300);
if (ptv1 == 1) { //si ptv1 esta activado
if (negativo == 1) { //si la variable negativo esta en 1
salir = cero + profun; //el resultado de la variable salir sera con esta formula
thir = salir - 22; //formula de thir dependiente dela variable salir
} else { //sino
salir = cero - profun; //el resultado de la variable salir sera con esta formula
thir = salir - 22; //formula de thir dependiente dela variable salir
}
}
if (ptv1 == 0) { //si ptv1 esta activado
salir = unionFB5.datoF5; //la variable salir proviene de la eeprom
thir = salir - 22; //formula de thir dependiente dela variable salir
}
 lcd.clear();//limpiar lcd
counter1 = 1; //resetear variable
negativo = 0; //dejar variable en cero
menu2();//volver al menu
}
if (key == '*') { //borrar un digito y limpiar lcd
if (counter1 > 6) {
rt = counter1 + 5;
lcd.setCursor(rt, 2);
lcd.print(" ");
counter1 = counter1 - 3;
} else {
rt = counter1 + 8;
lcd.setCursor(rt, 2);
lcd.print(" ");
}
if (counter1 > 1) {
counter1 = counter1 - 1;
} else {
lcd.setCursor(rt + 1, 2);
lcd.print(" ");
negativo = 0;
}
}
break;
}
}
}
}

profth();//volver a funcion
}

void recordar_th() {
//agregar valor de una variable sin necesidad de calibrar algun motor simplemente se agrega el
valor y este se guarda en la eeprom
lcd.setCursor(0, 0);
lcd.print("actualmente:");
lcd.print(unionFB8.datoF8);//mostrar valor actual del valor
lcd.setCursor(0, 1);
lcd.print("RECORDAR TH(mm):");

if (keypad.getKeys()) { /*INGRESO DE TECLADO LA MISMA LOGICA*/

for (int i = 0; i < LIST_MAX; i++) {
switch (keypad.key[i].kstate) {
case PRESSED:
if ( keypad.key[i].stateChanged ) {
char key = keypad.key[i].kchar;
if (key == 'C') { //volver al inicio
delay(300);
lcd.clear();
menu2();
}
if (key == '#') { //agregar coma
delay(300);
counter1 = counter1 + 5;
rt1 = counter1 + 4;
 lcd.setCursor(rt1, 2);
lcd.print(",");
}

if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agregar digito a la lcd y mover cursor
lcd.setCursor(0, 1);
counter1 = counter1 + 1;
if (counter1 > 6) {
rt1 = counter1 + 4;
} else {
rt1 = counter1 + 8;
}
lcd.setCursor(rt1, 2);
lcd.print(keypad.key[i].kchar);
lcd.setCursor(rt1 + 1, 2);
}
if ((key != '*') && (key != 'B') && (key != '#') && (key != 'A') && (key != 'C') && (key != 'K')) {
//agrupar digitos ingresados(decena centena)
delay(300);
if (counter1 == 2) { //unidad
char hy = keypad.key[i].kchar;
p11 = char(hy) - 48;
if (p11 < 0) {
p11 = 0;
}
res1 = p11;
}
if (counter1 == 3) { //decena
p22 = keypad.key[i].kchar - 48;
if (p22 < 0) {
p22 = 0;
}
res1 = (p11 * 10) + p22;
}
if (counter1 == 4) { //centena
p33 = keypad.key[i].kchar - 48;
if (p33 < 0) {
p33 = 0;
}
counter1 = 1;
y11 = 1;
res1 = (p11 * 100) + (p22 * 10) + p33;
}
if (counter1 > 7) { //decimal
c11 = keypad.key[i].kchar - 48;
resc1 = (c11 / 10);
}
ajuste_recordar = res1 + resc1; //suma total de valor entero y decimal
}
if (key == 'K') { //cuando el digito del teclado es 'K' guarda el nuevo valor ingreado fraccionado
en la nueva eeprom
delay(300);
unionFB8.datoF8 = ajuste_recordar;//guardar valor en la varibale para fraccionar en la
eeprom
EEPROM.write(110, unionFB8.datoB8[0]);
EEPROM.write(111, unionFB8.datoB8[1]);
 EEPROM.write(112, unionFB8.datoB8[2]);
EEPROM.write(113, unionFB8.datoB8[3]);
delay(60);
//leer datos en de la eeprom y guardar en la variable
unionFB8.datoB8[0] = EEPROM.read(110);
unionFB8.datoB8[1] = EEPROM.read(111);
unionFB8.datoB8[2] = EEPROM.read(112);
unionFB8.datoB8[3] = EEPROM.read(113);
counter = 1;
ajuste_recordar = unionFB8.datoF8; //guardar valor leido en varibale
lcd.clear();//limpiar lcd
counter1 = 1;
menu2(); //volver al menu
}
if (key == '*') { //borrar un digito y limpiar lcd
if (counter1 > 6) {
rt = counter1 + 5;
lcd.setCursor(rt, 2);
lcd.print(" ");
counter1 = counter1 - 3;
} else {
rt = counter1 + 8;
lcd.setCursor(rt, 2);
lcd.print(" ");
}
if (counter1 > 1) {
counter1 = counter1 - 1;
} else {
lcd.setCursor(rt + 1, 2);
lcd.print(" ");
}
}
break;
}
}
}
}
recordar_th();//volver a funcion
}