Tabla de contenido:
/*
////////////// DESCRIPCIÓN /////////////////////////////////// ////////////////////////////
Esta es una aplicación para controlar un motor de vacío dental.
El motor necesita una señal de 24 voltios (a través de un relé conectado a la salida digital de arduino) para encenderse.
Cuando está encendido, llena una bota con líquidos de la boca del paciente.
La botella tiene dos interruptores de nivel (sensores) para nivel BAJO y ALTO de líquido.
El estado del motor debe estar ENCENDIDO hasta que el líquido alcance un nivel alto. Luego, el estado del motor debe estar APAGADO para que el líquido se drene (eso ocurre solo cuando el motor está apagado) y luego se enciende nuevamente.
Todo esto funciona cuando las puntas de vacío dental están en manos de los médicos.
El soporte para puntas de vacío dental tiene un interruptor, de modo que cuando se coloca en el soporte, el interruptor está ABIERTO y cuando está en la mano del dentista, el interruptor está CERRADO.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
***************** código de ALEXANDROS PAGONIDIS http://www.BiomedicalTechnology.gr ******************** *************************************
*/
#incluir
sin firmar mucho tiempo;
sin firmar mucho tiempo2;
///// *** números de pines ************************ /////
int lowLevelPin = 2; // pin digital (2) conectado al interruptor de nivel bajo de bootle. El pin 1 del interruptor va al pin digital de arduino y el pin 2 del interruptor va a TIERRA.
int highLevelPin = 3; // pin digital (3) conectado al interruptor HIGH level de bootle. El pin 1 del interruptor va al pin digital de arduino y el pin 2 del interruptor va a TIERRA.
int valveTipsPin = 4; // pin digital (4) conectado al interruptor del soporte donde se colocan las puntas de vacío. El pin 1 del interruptor va al pin digital de arduino y el pin 2 del interruptor va a TIERRA.
int motorPin = 12; // pin digital 5V DC módulo de relé que controla el controlador de CA de 24V CA (CAUSA QUE MI MÓDULO CHINO ES ESTÚPIDO LA INVERSIÓN ESTÁ INVERTIDA DE MANERA QUE SE APAGUE PARA NO ENCENDER EL MOTOR)
int ledPin = 13; // led interno de tablero arduino
/*
ESTA CONEXIONES SON PARA SILLA ESPECÍFICA DE SIRONA CON CATANNI ELECTRONICS
PINS Y ALGUNOS DE COLORES DE CABLES:
1,19,12,13,14: NO CONECTADO
2, 3: 24VAC ENTRADA DESDE LA CAJA
9,11: 24VAC SALIDA AL MOTOR (LOS PINES 3,9 SON PINS DE UN RELÉ NORMALMENTE ABIERTO)
4, 5: INTERRUPTOR DE CONSEJOS (DONDE EN PIN 4 CABLES AMARILLO MARRON 5 CABLES DE GRIS BLANCO
6: BOTTLE SENSOR DE ALTO NIVEL (CABLE ROJO)
7: BOTTLE SENSOR DE NIVEL BAJO (CABLE BLANCO)
8: BOTELLA COMÚN, MEDIO (NEGRO DEL CABLE)
*/
///// *** valores de estado de swithes (ALTO = ABIERTO o BAJO = CERRAR)
int valveTipsVal;
int lowLevelVal;
int highLevelVal;
///// *** tiempos de retardo en msecs ******************* /////
int timeOfReadings = 200;
int problemInLowLevelSwitch = 8000;
int timeOfMotorMinON = 4000;
int timeOfMotorMaxON = 8000;
int timeOfTipOnStand = 2500;
int timeOfTipRest = 999;
///// *** val que indica si el motor está ENCENDIDO O APAGADO *** ///
int motorState; // obtiene valores de 0 o 1
//////////////////////////////////////
configuración del vacío ()
{
// configura los pines como entrada y habilita la resistencia de pull-up interna
pinMode (lowLevelPin, INPUT_PULLUP);
pinMode (highLevelPin, INPUT_PULLUP);
pinMode (valveTipsPin, INPUT_PULLUP);
// configurar pines como salidas
pinMode (motorPin, SALIDA);
pinMode (ledPin, SALIDA); // indicador interno en chip led
motorOFF (); // Cuando arudino TIPS_CHECKs up motor debe estar apagado
} // fin de la configuración
////////////////////////////////
bucle de vacío ()
{
/*
Lecturas de DigitalRead con INPUT_PULLUP:
ALTO cuando un interruptor o botón es como una conexión abierta a tierra.
BAJO cuando un interruptor o botón es como una conexión cerrada a tierra.
*/
valveTipsVal = digitalRead (valveTipsPin); retraso (1); //leer
lowLevelVal = digitalRead (lowLevelPin); delay (1); // todos
highLevelVal = digitalRead (highLevelPin); delay (1); // swithes
////////////////////////////////////////
TIPS_CHECK:
while (valveTipsVal == LOW) // TIPS_CHECK mientras ***** cuando las puntas de vacío están en las manos del dentista, el interruptor del soporte está cerrado. *****
{
valveTipsVal = digitalRead (valveTipsPin); retraso (1);
if (valveTipsVal == HIGH)
{goto TIPS_CHECK;} // verifique todos los niveles de código si las puntas de las válvulas están en posición de pie y si es así goto TIPS_CHECK
retraso (timeOfReadings); // hora de las lecturas … espere a que los sensores se estabilicen y se calmen el procesador de muchas lecturas
LEVEL_CHECK_RUN:
{
lowLevelVal = digitalRead (lowLevelPin); delay (1); //leer
highLevelVal = digitalRead (highLevelPin); delay (1); // nivel swithes
if (lowLevelVal == HIGH && highLevelVal == HIGH) // si el interruptor de nivel alto está ABIERTO, el interruptor de nivel bajo está ABIERTO
{lowLevelVal = digitalRead (lowLevelPin); retraso (1);
highLevelVal = digitalRead (highLevelPin); delay (1);
motorON ();
}
if (highLevelVal == HIGH && lowLevelVal == LOW) // si el interruptor de nivel alto está ABIERTO, el interruptor de nivel bajo CIERRE
{lowLevelVal = digitalRead (lowLevelPin); retraso (1);
highLevelVal = digitalRead (highLevelPin); delay (1);
motorON ();
}
while (highLevelVal == LOW) // LEVEL_CHECK_RUN mientras // el interruptor de nivel alto está CERRADO
{
highLevelVal = digitalRead (highLevelPin); delay (1);
valveTipsVal = digitalRead (valveTipsPin); retraso (1);
if (valveTipsVal == HIGH)
{goto TIPS_CHECK;} // verifique todos los niveles de código si las puntas de las válvulas están en posición de pie y si es así goto TIPS_CHECK
motorOFF ();
if (highLevelVal == HIGH) // si !!! 03 !!! Necesito un "if" antes de tiempo, así que obtén tiempo y corre una vez fuera del ciclo while
{
int runonce = 0; // para ejecutar una vez algunos procedimientos dentro de la próxima !!! 03 !!!
tiempo = milis ();
while (highLevelVal == HIGH) // mientras !!! 03 !!!
{lowLevelVal = digitalRead (lowLevelPin); retraso (1); //leer
highLevelVal = digitalRead (highLevelPin); delay (1); // nivel swithes
valveTipsVal = digitalRead (valveTipsPin); retraso (1);
if (valveTipsVal == HIGH)
{goto TIPS_CHECK;} // verifique todos los niveles de código si las puntas de las válvulas están en posición de pie y si es así goto TIPS_CHECK
tiempo2 = milis ();
if (time2> (time + problemInLowLevelSwitch) && lowLevelVal! = HIGH && (runonce == 0)) // si el interruptor de nivel bajo tiene un problema y no se apaga
{runonce ++; // con un parámetro runonce para detener el conteo
retraso (timeOfMotorMinON); // el motor permanece apagado por un retraso y luego se vuelve a encender
motorON ();
// ir a LEVEL_CHECK_RUN; // necesito usar esto en caso de que no uses la sentencia runonce
}
if (lowLevelVal == HIGH && (runonce == 0)) // si el interruptor de nivel bajo está cerrado
{runonce ++;
retraso (timeOfMotorMaxON); // estancia en el motor desactivada de foa y luego encendida de nuevo
// Entonces los líquidos se van a escurrir.
motorON ();
// ir a LEVEL_CHECK_RUN; // No lo use pero si lo usa funciona bien.
}
} // fin de tiempo !!! 03 !!!
} // fin de si !!! 03 !!!
} // finaliza LEVEL_CHECK_RUN mientras
} // fin de LEVEL_CHECK_RUN
} // el final de TIPS_CHECK mientras ****** bajo este código de línea pertenece al caso que las sugerencias están en pie *******
//******************************** *******
// motorOFF ();
Interruptor (motorState) // cuando las puntas de vacío están en el soporte, el interruptor del soporte está abierto, por lo que el motor debe estar apagado.
// pero si el motor estaba encendido, entonces cuando el dentista pone la punta en el soporte
// debe haber un retraso para que los residuos de líquido en el interior del tubo de vacío vayan a la posición inicial y luego al drenaje.
{
caso 1: retraso (timeOfTipOnStand);
motorOFF ();
descanso;
caso 0: retraso (1);
motorOFF ();
descanso;
por defecto: romper
}
retraso (timeOfTipRest); // precaución en caso de que la punta no encaje o salga de inmediato.
} // Fin del bucle ////////////////////////////////////////////
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
void motorON () // enciende el motor y motorstate 1
{// esto es para el interruptor (estado del motor)
digitalWrite (motorPin, LOW); // SÍ BAJO (lógica invertida), causa de un módulo chino estúpido
retraso (1);
motorState = 1;
digitalWrite (ledPin, HIGH);
retraso (1);
}
void motorOFF () // apaga el motor y motorstate 0
{// esto es para el interruptor (estado del motor)
digitalWrite (motorPin, HIGH); // SÍ ALTO (lógica invertida), causa de un módulo chino estúpido
retraso (1);
motorState = 0;
digitalWrite (ledPin, LOW);
retraso (1);
}
//////////////////////////////////////////////////////
void blink () // ingresa el código para probar dónde estás cuando usas swithes
{
digitalWrite (ledPin, HIGH); // enciende el LED
retraso (200); // espera un segundo
digitalWrite (ledPin, LOW); // apaga el LED
retraso (200); // espera un segundo
digitalWrite (ledPin, HIGH); // enciende el LED
retraso (200); // espera un segundo
}///////////////////////////////////////