- Introducción
- Motor paso a paso
- Descripción del conector físico
- Programa en java para el control del motor
- Materiales
- Conclusiones
Introducción
Con este proyecto hemos realizado el control d un panel solar mediante un motor paso a paso que hace girar el panel solar en dirección al sol mediante los conocimientos de programación en java vistos en laboratorio y teoría de computación II tuvimos el control del motor paso a paso.
2. PANEL SOLAR
Una generación solar es aquella instalación en la que se aprovecha la radiación solar para producir energía eléctrica. Este proceso puede realizarse mediante siguiente vía:
Fotovoltaica: Hacen incidir las radiaciones solares sobre una superficie de un cristal semiconductor, llamada célula solar, y producir en forma directa una corriente eléctrica por efecto Fotovoltaico. Este tipo de centrales se están instalando en países donde el transporte de energía eléctrica se debería de realizar
desde mucha distancia, y hasta ahora su empleo es básicamente para iluminación, y algunas aplicaciones domésticas.
Qué es un panel solar de todos modos? Es básicamente una caja que contiene un conjunto de células solares. Las células solares son las cosas que hacen el trabajo real de convertir la luz solar en electricidad. Sin embargo, se necesita una gran cantidad de células para obtener una significativa cantidad de energía, y son muy frágiles, por lo que las células individuales se montan en los paneles. Los paneles tienen suficientes células para hacer una buena cantidad de energía y proteger las células de los elementos.
Motor paso a paso
Los motores paso a paso son ideales para la construcción de mecanismos en donde se requieren movimientos muy precisos.
La característica principal de estos motores es el hecho de poder moverlos un paso a la vez por cada pulso que se le aplique. Este paso puede variar desde 90° hasta pequeños movimientos de tan solo 1.8°, es decir, que se necesitarán 4 pasos en el primer caso (90°) y 200 para el segundo caso (1.8°), para completar un giro completo de 360°.
Estos motores poseen la habilidad de poder quedar enclavados en una posición o bien totalmente libres. Si una o más de sus bobinas está energizada, el motor estará enclavado en la posición correspondiente y por el contrario quedará completamente libre si no circula corriente por ninguna de sus bobinas.
En este capítulo trataremos solamente los motores P-P del tipo de imán permanente, ya que estos son los mas usados en robótica.
Principio de funcionamiento
Básicamente estos motores están constituidos normalmente por un rotor sobre el que van aplicados distintos imanes permanentes y por un cierto número de bobinas excitadoras bobinadas en su estator.
Las bobinas son parte del estator y el rotor es un imán permanente. Toda la conmutación (o excitación de las bobinas) deber ser externamente manejada por un controlador.
Imagen del rotor
Imagen de un estator de 4 bobinas
Existen dos tipos de motores paso a paso de imán permanente:
Bipolar: Estos tiene generalmente cuatro cables de salida (ver figura 1). Necesitan ciertos trucos para ser controlados, debido a que requieren del cambio de dirección del flujo de corriente a través de las bobinas en la secuencia apropiada para realizar un movimiento.
En figura 3 podemos apreciar un ejemplo de control de estos motores mediante el uso de un puente en H (H-Bridge). Como se aprecia, será necesario un H-Bridge por cada bobina del motor, es decir que para controlar un motor Paso a Paso de 4 cables (dos bobinas), necesitaremos usar dos H-Bridges iguales al de la figura 3 . El circuito de la figura 3 es a modo ilustrativo y no corresponde con exactitud a un H-Bridge. En general es recomendable el uso de H-Bridge integrados como son los casos del L293 (ver figura 3 bis).
Unipolar: Estos motores suelen tener 6 o 5 cables de salida, dependiendo de su conexionado interno (ver figura 2). Este tipo se caracteriza por ser más simple de controlar. En la figura 4 podemos apreciar un ejemplo de conexionado para controlar un motor paso a paso unipolar mediante el uso de un ULN2803, el cual es una array de 8 transistores tipo Darlington capaces de manejar cargas de hasta 500mA. Las entradas de activación (Activa A, B , C y D) pueden ser directamente activadas por un microcontrolador.
Secuencias para manejar motores paso a paso
Una referencia importante:
Cuando se trabaja con motores P-P usados o bien nuevos, pero de los cuales no tenemos hojas de datos. Es posible averiguar la distribución de los cables a los bobinados y el cable común en un motor de paso unipolar de 5 o 6 cables siguiendo las instrucciones que se detallan a continuación:
1. Aislando el cable(s) común que va a la fuente de alimentación: Como se aprecia en las figuras anteriores, en el caso de motores con 6 cables, estos poseen dos cables comunes, pero generalmente poseen el mismo color, por lo que lo mejor es unirlos antes de comenzar las pruebas.
Usando un tester para chequear la resistencia entre pares de cables, el cable común será el único que tenga la mitad del valor de la resistencia entre ella y el resto de los cables.
Esto es debido a que el cable común tiene una bobina entre ella y cualquier otro cable, mientras que cada uno de los otros cables tienen dos bobinas entre ellos. De ahí la mitad de la resistencia medida en el cable común.
2.Identificando los cables de las bobinas (A, B, C y D): aplicar un voltaje al cable común (generalmente 12 volts, pero puede ser más o menos) y manteniendo uno de los otros cables a masa (GND) mientras vamos poniendo a masa cada uno de los demás cables de forma alternada y observando los resultados.
El proceso se puede apreciar en el siguiente cuadro:
Seleccionar un cable y conectarlo a masa. Ese será llamado cable A.
Manteniendo el cable A conectado a masa, probar cuál de los tres cables restantes provoca un paso en sentido antihorario al ser conectado también a masa. Ese será el cable B.
Manteniendo el cable A conectado a masa, probar cuál de los dos cables restantes provoca un paso en sentido horario al ser conectado a masa. Ese será el cable D.
El último cable debería ser el cable C. Para comprobarlo, basta con conectarlo a masa, lo que no debería generar movimiento alguno debido a que es la bobina opuesta a la A.
Nota: La nomenclatura de los cables (A, B, C, D) es totalmente arbitraria.
Secuencias para manejar motores paso a paso (unipolar)
Existen tres métodos para el control de este tipo de motores , según las secuencias de encendido de bobinas. Las secuencias son las siguientes:
Descripción del conector físico
La conexión del puerto paralelo al mundo exterior se realiza mediante un conector hembra DB25. Observando el conector de frente y con la parte que tiene mayor número de pines hacia arriba, se numera de derecha a izquierda y de arriba a abajo, del 1 al 13 (arriba) y del 14 al 25 (abajo).
En este conector:
8 líneas (pines) son para salida de datos (bits de DATOS). Sus valores son únicamente modificables a través de software, y van del pin 2 (dato 0, D0) al pin 9 (dato 7, D7).
5 líneas son de entrada de datos (bits de ESTADO), únicamente modificables a través del hardware externo. Estos pines son: 11, 10, 12, 13 y 15, del más al menos significativo.
4 líneas son de control (bits de CONTROL), numerados del más significativo al menos: 17, 16, 14 y 1. Habitualmente son salidas, aunque se pueden utilizar también como entradas y, por tanto, se pueden modificar tanto por software como por hardware.
las líneas de la 18 a la 25 son la tierra.
En la siguiente tabla se detallan la nomenclatura y descripción de cada línea. La columna "Centronics pin" se refiere a las líneas del conector tipo Centronics usado en las impresoras. La columna E/S se refiere al dato visto desde el lado del PC.
En la siguiente tabla se detallan la nomenclatura y descripción de cada línea. La columna "Centronics pin" se refiere a las líneas del conector tipo Centronics usado en las impresoras. La columna E/S se refiere al dato visto desde el lado del PC
El nombre de cada señal corresponde a la misión que cumple cada línea con relación a la impresora, el periférico para el que fue diseñado el puerto paralelo. Las señales activas a nivel bajo aparecen con la barra de negación (por ejemplo, Strobe). Cuando se indica alto o bajo se refiere a la tensión en el pin del conector. Alto equivale a ~5V en TTL y bajo a ~0V en TTL.
La práctica
Unipolar: Para controlar un motor paso a paso unipolar deberemos alimentar el común del motor con Vcc y conmutaremos con masa en los cables del devanado correspondiente con lo que haremos pasar la corriente por la bobina del motor adecuada y esta generará un campo electromagnético que atraerá el polo magnetizado del rotor y el eje del mismo girará.
Características técnicas
Condiciones Máximas
Tensión de alimentación | 0 a +7v. | |
Tensiones de entrada | -2.5 a vcc + Vcc+1v | |
Corriente de salida | 100mA | |
Temperatura ambiente con alimentación | -65 a +125° c | |
Circuito de aplicación típico:La configuración mas sencilla es la de la del esquema de la figura. Sus salidas atacando directamente a transistores npn para la excitación de cada bobina del motor paso a paso. los pines de comparación comp1 y comp2 polarizados a tierra para que las salidas se encuentren permanentemente habilitadas. El pin de 1/2 paso polarizado a VCC para que el controlador genere una salida de paso completo. La entrada izq/der permite definir la dirección de giro del motor paso a paso, la cual será validada en el primer pulso presente en la entrada de reloj. Por cada pulso entregado al pin de reloj el motor paso a paso dará un paso.
5. Materiales
Estructura de una casa hechas de cartulina
panel solar
brazo de plástico (que sirvió como acoplamiento para el motor paso a paso y el sostenimiento del panel solar)
Motor paso a paso unipolar
Alicate
Multimetro
Cinta aislante
Circuito:
Resistecia de 220
Transistores TIP 31C
Un circuito LC 7473
4 leds
Conectores
2 Protoboard
1 cable de puerto paralelo LPT1
1 fuente de tensión de 5 voltios
Software:
1 computadora con conector LPT1
Programa READY TO PROGRAM
Programa de control de secuencias realizado en java
6. Procedimiento :
Primero se procedió a armar el circuito en un protoboard con los conectores, leds, transistores, resistencias, luego una fuente para ver si circula corriente utilizamos un multimetro para calcular cuanta corriente circula y cuanto voltaje esta expulsando.
Luego conectamos el motor paso a paso en el protoboard siguiendo las indicaciones del la conexión de un motor paso a paso a un circuito, después conectamos el puerto paralelo a la computadora y luego al circuito en seguidamente se debe desactivar el bloqueo que tiene el puerto paralelo y después introducir el programa dentro de java para y hacer correr el programa antes se debe hacer una prueba de cómo marcha el programa con el motor paso a paso si todo sale bien entonces se debe seguir con el armado del siguiente paso que se explica a continuación. Pero si no hubiera buen funcionamiento el programa con el motor paso a paso entonces se debe revisar la conexión del motor paso a paso al circuito, si eso o es problema entonces revisar si el motor paso a paso no esta esta en optimas condiciones para funcionar.
Lugo de que el programa funciona con el motor paso a paso entonces se le acopla un brazo al motor después el panel solar se introduce al otro extremo del brazo el cual debe quedar bien estático a un Angulo de 45 grados para que sea reflejada por el sol y absorba todo la energía calorífica que produce el sol. Se debe tomar una leída con el multimetro cuanto voltaje vota el panel solar, si el valor es lo suficientemente grande entonces se logra hacer una aplicación.
La aplicación es que lográramos encender con un panel solar una vivienda que estaba conectado con leds y unos focos pequeños el cual estaban dentro de la habitación
Programa en java para el control del motor
import parport.ParallelPort;
import java.io.*;
public class proyecto_solar
{
//——————————————
public static class Aplicacion
{
private ParallelPort lpt1;
public Aplicacion () throws IOException
{
int op, n, k, u, c, hora, cp, cpt, m, t, g, d, f;
BufferedReader w = new BufferedReader (new InputStreamReader (System.in));
lpt1 = new ParallelPort (888); // 0x378 normalmente es utilizado para impresora LPT1
lpt1.write (0);
System.out.println ("ntControl de un panel solar por javan");
int opcion;
do
{
System.out.println ("1) Demostracion de giro ");
System.out.println ("2) Localizacion a la hora del dia");
System.out.println ("3) Salir.");
opcion = Integer.parseInt (w.readLine ());
switch (opcion)
{
case 1:
do
{
System.out.println ("1.- Giro horario");
System.out.println ("2.- Reversa(Giro antihorario)");
System.out.println ("3.- Giro en ambos sentidos automaticamente");
System.out.println ("4.- Volver al menu de opciones");
op = Integer.parseInt (w.readLine ());
switch (op)
{
case 1:
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
break;
case 2:
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
break;
case 3:
System.out.println ("Introducir numero de secuencias de 180 grados");
n = Integer.parseInt (w.readLine ());
if (n % 2 == 0)
{
for (int r = 0 ; r <= n ; r++)
{
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
k = (int) Math.pow (2, j);
lpt1.write (k);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
}
else
{
for (int r = 0 ; r <= n ; r++)
{
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
k = (int) Math.pow (2, j);
lpt1.write (k);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
System.out.println ("Volver al punto de partida presione la tecla 1");
u = Integer.parseInt (w.readLine ());
if (u == 1)
{
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
c = (int) Math.pow (2, j);
lpt1.write (c);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
}
break;
}
}
while (op != 4)
;
break;
case 2:
do
{
System.out.println ("Hora del dia entre 07:00 am a 18:00 pm");
System.out.print ("Introducir la hora : ");
hora = Integer.parseInt (w.readLine ());
}
while ((hora < 7) || (hora > 18));
if (hora == 7)
{
cp = 0 * 2;
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
m = (int) Math.pow (2, j);
lpt1.write (m);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
System.out.println ("Terminar el giro y volver al punto de partida, introducir numero 1");
System.out.println ("Volver al punto de partida,introducir el numero 2");
t = Integer.parseInt (w.readLine ());
if (t == 1)
{
cpt = 22 – cp;
for (int i = 0 ; i <= cpt ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
d = (int) Math.pow (2, j);
lpt1.write (d);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
if (t == 2)
{
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
f = (int) Math.pow (2, j);
lpt1.write (f);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
}
if (hora == 8)
{
cp = 1 * 2;
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
m = (int) Math.pow (2, j);
lpt1.write (m);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
System.out.println ("Terminar el giro y volver al punto de partida, introducir numero 1");
System.out.println ("Volver al punto de partida,introducir el numero 2");
t = Integer.parseInt (w.readLine ());
if (t == 1)
{
cpt = 22 – cp;
for (int i = 0 ; i <= cpt ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
d = (int) Math.pow (2, j);
lpt1.write (d);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
if (t == 2)
{
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
f = (int) Math.pow (2, j);
lpt1.write (f);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
}
if (hora == 9)
{
cp = 2 * 2;
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
m = (int) Math.pow (2, j);
lpt1.write (m);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
System.out.println ("Terminar el giro y volver al punto de partida, introducir numero 1");
System.out.println ("Volver al punto de partida,introducir el numero 2");
t = Integer.parseInt (w.readLine ());
if (t == 1)
{
cpt = 22 – cp;
for (int i = 0 ; i <= cpt ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
d = (int) Math.pow (2, j);
lpt1.write (d);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
if (t == 2)
{
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
f = (int) Math.pow (2, j);
lpt1.write (f);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
}
if (hora == 10)
{
cp = 3 * 2;
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
m = (int) Math.pow (2, j);
lpt1.write (m);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
System.out.println ("Terminar el giro y volver al punto de partida, introducir numero 1");
System.out.println ("Volver al punto de partida,introducir el numero 2");
t = Integer.parseInt (w.readLine ());
if (t == 1)
{
cpt = 22 – cp;
for (int i = 0 ; i <= cpt ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
d = (int) Math.pow (2, j);
lpt1.write (d);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
if (t == 2)
{
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
f = (int) Math.pow (2, j);
lpt1.write (f);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
}
if (hora == 11)
{
cp = 4 * 2;
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
m = (int) Math.pow (2, j);
lpt1.write (m);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
System.out.println ("Terminar el giro y volver al punto de partida, introducir numero 1");
System.out.println ("Volver al punto de partida,introducir el numero 2");
t = Integer.parseInt (w.readLine ());
if (t == 1)
{
cpt = 22 – cp;
for (int i = 0 ; i <= cpt ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
d = (int) Math.pow (2, j);
lpt1.write (d);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
if (t == 2)
{
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
f = (int) Math.pow (2, j);
lpt1.write (f);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
}
if (hora == 12)
{
cp = 5 * 2;
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
m = (int) Math.pow (2, j);
lpt1.write (m);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
System.out.println ("Terminar el giro y volver al punto de partida, introducir numero 1");
System.out.println ("Volver al punto de partida,introducir el numero 2");
t = Integer.parseInt (w.readLine ());
if (t == 1)
{
cpt = 22 – cp;
for (int i = 0 ; i <= cpt ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
d = (int) Math.pow (2, j);
lpt1.write (d);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
if (t == 2)
{
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
f = (int) Math.pow (2, j);
lpt1.write (f);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
}
if (hora == 13)
{
cp = 6 * 2;
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
m = (int) Math.pow (2, j);
lpt1.write (m);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
System.out.println ("Terminar el giro y volver al punto de partida, introducir numero 1");
System.out.println ("Volver al punto de partida,introducir el numero 2");
t = Integer.parseInt (w.readLine ());
if (t == 1)
{
cpt = 22 – cp;
for (int i = 0 ; i <= cpt ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
d = (int) Math.pow (2, j);
lpt1.write (d);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
for (int i = 0 ; i <= 22 ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
g = (int) Math.pow (2, j);
lpt1.write (g);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
if (t == 2)
{
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 3 ; j >= 0 ; j–)
{
f = (int) Math.pow (2, j);
lpt1.write (f);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
}
}
if (hora == 14)
{
cp = 7 * 2;
for (int i = 0 ; i <= cp ; i++)
{
for (int j = 0 ; j <= 3 ; j++)
{
m = (int) Math.pow (2, j);
lpt1.write (m);
try
{
Thread.sleep (100);
}
catch (InterruptedException ie)
{
ie.printStackTrace ();
}
}
}
System.out.println ("Terminar el giro y volver al punto de partida, introducir numero 1");
System.out.println ("Volver al punto de partida,introducir el numero 2");
| Página siguiente |