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 | 0 a +7v. | |
Tensiones de entrada | -2.5 a vcc + Vcc+1v | |
Corriente de salida | 100mA | |
Temperatura ambiente con | -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
cartulinapanel 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
LPT11 fuente de tensión de 5
voltios
Software:
1 computadora con conector
LPT1Programa 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
7. 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  |