Java - Reducción de funciones

 
Vista:
sin imagen de perfil
Val: 21
Ha disminuido su posición en 4 puestos en Java (en relación al último mes)
Gráfica de Java

Reducción de funciones

Publicado por Jose_Romero (10 intervenciones) el 10/11/2018 18:42:15
Buenas tardes, tengo 3 funciones en las que hago repetir código bastante veces y me gustaría saber si se pudiese reducir con algún bucle for o algo, los método son los siguientes:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#define num_patas 6
#define num_servos 3
#define SERVO_COX 0
#define SERVO_FEM 1
#define SERVO_TIB 2
 
int mov_home[num_patas][num_servos] = { {125,90,87},
                                        {85,90,90},
                                        {60,90,100},
                                        {60,90,85},
                                        {93,90,90},
                                        {135,90,80}};
 
int mov_avanza[num_patas][num_servos] = { {140,135,135},
                                          {100,135,135},
                                          {75,135,135},
                                          {45,55,55},
                                          {78,55,55},
                                          {120,55,55}};
 
int mov_retrocede[num_patas][num_servos] = { {110,90,90},
                                             {70,90,90},
                                             {45,90,90},
                                             {75,90,90},
                                             {108,90,90},
                                             {150,90,90}};
 
public void home(){
    mueve_servo(&patas[0][SERVO_COX], mov_home[0][SERVO_COX]);
    mueve_servo(&patas[0][SERVO_FEM], mov_home[0][SERVO_FEM]);
    mueve_servo(&patas[0][SERVO_TIB], mov_home[0][SERVO_TIB]);
    mueve_servo(&patas[1][SERVO_COX], mov_home[1][SERVO_COX]);
    mueve_servo(&patas[1][SERVO_FEM], mov_home[1][SERVO_FEM]);
    mueve_servo(&patas[1][SERVO_TIB], mov_home[1][SERVO_TIB]);
    mueve_servo(&patas[2][SERVO_COX], mov_home[2][SERVO_COX]);
    mueve_servo(&patas[2][SERVO_FEM], mov_home[2][SERVO_FEM]);
    mueve_servo(&patas[2][SERVO_TIB], mov_home[2][SERVO_TIB]);
    mueve_servo(&patas[3][SERVO_COX], mov_home[3][SERVO_COX]);
    mueve_servo(&patas[3][SERVO_FEM], mov_home[3][SERVO_FEM]);
    mueve_servo(&patas[3][SERVO_TIB], mov_home[3][SERVO_TIB]);
    mueve_servo(&patas[4][SERVO_COX], mov_home[4][SERVO_COX]);
    mueve_servo(&patas[4][SERVO_FEM], mov_home[4][SERVO_FEM]);
    mueve_servo(&patas[4][SERVO_TIB], mov_home[4][SERVO_TIB]);
    mueve_servo(&patas[5][SERVO_COX], mov_home[5][SERVO_COX]);
    mueve_servo(&patas[5][SERVO_FEM], mov_home[5][SERVO_FEM]);
    mueve_servo(&patas[5][SERVO_TIB], mov_home[5][SERVO_TIB]);
}
 
 
public void avanza(){
    while(1){
        mueve_servo(&patas[1][SERVO_TIB], mov_avanza[1][SERVO_TIB]);
        mueve_servo(&patas[1][SERVO_FEM], mov_avanza[1][SERVO_FEM]);
        mueve_servo(&patas[3][SERVO_TIB], mov_avanza[3][SERVO_TIB]);
        mueve_servo(&patas[3][SERVO_FEM], mov_avanza[3][SERVO_FEM]);
        mueve_servo(&patas[5][SERVO_TIB], mov_avanza[5][SERVO_TIB]);
        mueve_servo(&patas[5][SERVO_FEM], mov_avanza[5][SERVO_FEM]);
        wait_ms(400);
        mueve_servo(&patas[1][SERVO_COX], mov_avanza[1][SERVO_COX]);
        mueve_servo(&patas[3][SERVO_COX], mov_avanza[3][SERVO_COX]);
        mueve_servo(&patas[5][SERVO_COX], mov_avanza[5][SERVO_COX]);
        mueve_servo(&patas[0][SERVO_COX], mov_retrocede[0][SERVO_COX]);
        mueve_servo(&patas[2][SERVO_COX], mov_retrocede[2][SERVO_COX]);
        mueve_servo(&patas[4][SERVO_COX], mov_retrocede[4][SERVO_COX]);
        wait_ms(400);
        mueve_servo(&patas[1][SERVO_TIB], mov_home[1][SERVO_TIB]);
        mueve_servo(&patas[1][SERVO_FEM], mov_home[1][SERVO_FEM]);
        mueve_servo(&patas[3][SERVO_TIB], mov_home[3][SERVO_TIB]);
        mueve_servo(&patas[3][SERVO_FEM], mov_home[3][SERVO_FEM]);
        mueve_servo(&patas[5][SERVO_TIB], mov_home[5][SERVO_TIB]);
        mueve_servo(&patas[5][SERVO_FEM], mov_home[5][SERVO_FEM]);
        wait_ms(400);
        mueve_servo(&patas[0][SERVO_TIB], mov_avanza[0][SERVO_TIB]);
        mueve_servo(&patas[0][SERVO_FEM], mov_avanza[0][SERVO_FEM]);
        mueve_servo(&patas[2][SERVO_TIB], mov_avanza[2][SERVO_TIB]);
        mueve_servo(&patas[2][SERVO_FEM], mov_avanza[2][SERVO_FEM]);
        mueve_servo(&patas[4][SERVO_TIB], mov_avanza[4][SERVO_TIB]);
        mueve_servo(&patas[4][SERVO_FEM], mov_avanza[4][SERVO_FEM]);
        wait_ms(400);
        mueve_servo(&patas[0][SERVO_COX], mov_avanza[0][SERVO_COX]);
        mueve_servo(&patas[2][SERVO_COX], mov_avanza[2][SERVO_COX]);
        mueve_servo(&patas[4][SERVO_COX], mov_avanza[4][SERVO_COX]);
        mueve_servo(&patas[1][SERVO_COX], mov_retrocede[1][SERVO_COX]);
        mueve_servo(&patas[3][SERVO_COX], mov_retrocede[3][SERVO_COX]);
        mueve_servo(&patas[5][SERVO_COX], mov_retrocede[5][SERVO_COX]);
        wait_ms(400);
        mueve_servo(&patas[0][SERVO_TIB], mov_home[0][SERVO_TIB]);
        mueve_servo(&patas[0][SERVO_FEM], mov_home[0][SERVO_FEM]);
        mueve_servo(&patas[2][SERVO_TIB], mov_home[2][SERVO_TIB]);
        mueve_servo(&patas[2][SERVO_FEM], mov_home[2][SERVO_FEM]);
        mueve_servo(&patas[4][SERVO_TIB], mov_home[4][SERVO_TIB]);
        mueve_servo(&patas[4][SERVO_FEM], mov_home[4][SERVO_FEM]);
        wait_ms(400);
        }
}
 
 
public void retrocede(){
    while(1){
        mueve_servo(&patas[1][SERVO_TIB], mov_avanza[1][SERVO_TIB]);
        mueve_servo(&patas[1][SERVO_FEM], mov_avanza[1][SERVO_FEM]);
        mueve_servo(&patas[3][SERVO_TIB], mov_avanza[3][SERVO_TIB]);
        mueve_servo(&patas[3][SERVO_FEM], mov_avanza[3][SERVO_FEM]);
        mueve_servo(&patas[5][SERVO_TIB], mov_avanza[5][SERVO_TIB]);
        mueve_servo(&patas[5][SERVO_FEM], mov_avanza[5][SERVO_FEM]);
        wait_ms(400);
        mueve_servo(&patas[1][SERVO_COX], mov_retrocede[1][SERVO_COX]);
        mueve_servo(&patas[3][SERVO_COX], mov_retrocede[3][SERVO_COX]);
        mueve_servo(&patas[5][SERVO_COX], mov_retrocede[5][SERVO_COX]);
        mueve_servo(&patas[0][SERVO_COX], mov_avanza[0][SERVO_COX]);
        mueve_servo(&patas[2][SERVO_COX], mov_avanza[2][SERVO_COX]);
        mueve_servo(&patas[4][SERVO_COX], mov_avanza[4][SERVO_COX]);
        wait_ms(400);
        mueve_servo(&patas[1][SERVO_TIB], mov_home[1][SERVO_TIB]);
        mueve_servo(&patas[1][SERVO_FEM], mov_home[1][SERVO_FEM]);
        mueve_servo(&patas[3][SERVO_TIB], mov_home[3][SERVO_TIB]);
        mueve_servo(&patas[3][SERVO_FEM], mov_home[3][SERVO_FEM]);
        mueve_servo(&patas[5][SERVO_TIB], mov_home[5][SERVO_TIB]);
        mueve_servo(&patas[5][SERVO_FEM], mov_home[5][SERVO_FEM]);
        wait_ms(400);
        mueve_servo(&patas[0][SERVO_TIB], mov_avanza[0][SERVO_TIB]);
        mueve_servo(&patas[0][SERVO_FEM], mov_avanza[0][SERVO_FEM]);
        mueve_servo(&patas[2][SERVO_TIB], mov_avanza[2][SERVO_TIB]);
        mueve_servo(&patas[2][SERVO_FEM], mov_avanza[2][SERVO_FEM]);
        mueve_servo(&patas[4][SERVO_TIB], mov_avanza[4][SERVO_TIB]);
        mueve_servo(&patas[4][SERVO_FEM], mov_avanza[4][SERVO_FEM]);
        wait_ms(400);
        mueve_servo(&patas[0][SERVO_COX], mov_retrocede[0][SERVO_COX]);
        mueve_servo(&patas[2][SERVO_COX], mov_retrocede[2][SERVO_COX]);
        mueve_servo(&patas[4][SERVO_COX], mov_retrocede[4][SERVO_COX]);
        mueve_servo(&patas[1][SERVO_COX], mov_avanza[1][SERVO_COX]);
        mueve_servo(&patas[3][SERVO_COX], mov_avanza[3][SERVO_COX]);
        mueve_servo(&patas[5][SERVO_COX], mov_avanza[5][SERVO_COX]);
        wait_ms(400);
        mueve_servo(&patas[0][SERVO_TIB], mov_home[0][SERVO_TIB]);
        mueve_servo(&patas[0][SERVO_FEM], mov_home[0][SERVO_FEM]);
        mueve_servo(&patas[2][SERVO_TIB], mov_home[2][SERVO_TIB]);
        mueve_servo(&patas[2][SERVO_FEM], mov_home[2][SERVO_FEM]);
        mueve_servo(&patas[4][SERVO_TIB], mov_home[4][SERVO_TIB]);
        mueve_servo(&patas[4][SERVO_FEM], mov_home[4][SERVO_FEM]);
        wait_ms(400);
        }
}

Arriba indico los #define y mueve_servo es una función definida previamente. Lo que quiero es intentar reducir esas funciones que no termino de lograr, no sé si con algún tipo de bucle, pero que tenga la misma función que ya tiene.

También quiero comentar que por ejemplo de la función retrocede antes de llegar al " wait_ms(400); " esos movimientos del servo que se observan se hacen todos de golpe, es decir, como en paralelo, a esto me refiero:
1
2
3
4
5
6
mueve_servo(&patas[1][SERVO_TIB], mov_avanza[1][SERVO_TIB]);
mueve_servo(&patas[1][SERVO_FEM], mov_avanza[1][SERVO_FEM]);
mueve_servo(&patas[3][SERVO_TIB], mov_avanza[3][SERVO_TIB]);
mueve_servo(&patas[3][SERVO_FEM], mov_avanza[3][SERVO_FEM]);
mueve_servo(&patas[5][SERVO_TIB], mov_avanza[5][SERVO_TIB]);
mueve_servo(&patas[5][SERVO_FEM], mov_avanza[5][SERVO_FEM]);


Muchas gracias !!
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

Reducción de funciones

Publicado por Tom (1559 intervenciones) el 10/11/2018 19:20:24
¿ No has caído en la cuenta de que estás en un foro sobre java ?
Me parece que en tu caso los #define estorban un poco.

1
2
3
4
5
6
7
public void home(){
  for(int p = 0; p < NUM_PATAS; p++) {
    for(int s = 0; s < NUM_SERVOS; s++) {
      mueve_servo(&patas[p][s], mov_home[p][s]);
    }
  }
}

Por otra parte, si lo necesitas, pon un wait_ms() tras cada mueve_servo() hasta que no se ejecuten "en paralelo".

Un define que te sería útil podría ser este (o parecido):
#define MUEVE_SERVO(P, S, F) mueve_servo(&patas[P][S], F[P][S])

que usarías:
MUEVE_SERVO(0, SERVO_COX, mov_home);
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
sin imagen de perfil
Val: 21
Ha disminuido su posición en 4 puestos en Java (en relación al último mes)
Gráfica de Java

Reducción de funciones

Publicado por Jose_Romero (10 intervenciones) el 10/11/2018 19:29:42
Vale, no he entendido muy bien lo del #define. No sé si eso sería para las funciones avanza y retrocede. Yo sí quiero que se ejecute en paralelo pero hasta el wait_ms que es cuando salta a lo siguiente. No sé si habría forma ya para el avanza y retrocede.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Reducción de funciones

Publicado por Tom (1559 intervenciones) el 10/11/2018 19:40:42
Bueno, entonces te propondría algo como esto:
1
2
3
4
5
for(int i : new int[] {1, 3, 5}) {
  for(int j : new int[]{2, 1}) {
    mueve_servo(...);
  }
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 21
Ha disminuido su posición en 4 puestos en Java (en relación al último mes)
Gráfica de Java

Reducción de funciones

Publicado por Jose_Romero (10 intervenciones) el 10/11/2018 19:52:52
No entiendo bien los bucles, ¿porque el segundo sería 2 y 1? ¿me podrías hacer un pequeño ejemplo? Y ya después continuo con el otro.

Gracias de nuevo!!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar