Programación de Robot: "Ninja" Esquivar fondo negro.

Autor: Carlos San Martin San Roman
Universidad Católica de Temuco.

Creatividad e innovación

Nivel 1: Identifica respuestas novedosas para resolver mejor las demandas del entorno cotidiano.

_____________________________________________________________________________

"Robot Ninja"

Una entrada similar a esta existe, pero hoy les mostrare esto entorno a la creatividad e innovación. Ya que muchos chicos, cuando comienzan por primera vez en la programación, se preguntan(en este caso NXT), como hacer esto o esto otro. Ahí es donde se encuentra la creatividad. Ya que uno debe pensar en cada aspecto de este. En este ejemplo, Esquivar puntos negros para que el robot no sea encontrado, ya que estos puntos "Son luces".

Es muy simple, y ya que en la programación, la creatividad es llegar a la solución de la manera mas sencilla les mostrare lo necesario para que este robot pueda lograr su misión.

(vídeo referencia)

Lo necesario

Primero tener el censor de luz y definir un umbral de luz(casi siempre utilizo 45)

luego implementar el uso de este umbral con condiciones "if" para que el robot haga algo cuando esto ocurra.

Codigo del Programa robot Ninja

/*Integrantes del grupo : Juan  Pablo Llancavil, Jorge Henríquez, Carlos Alberto San Martin y

Marcelo Riffo */

int GiroRandom;

int contador=0;

int numero=3;

#define umbral 45

task main()

{

SetSensorTouch(IN_4);

SetSensorLight(IN_1);

OnFwd(OUT_A, 79); //acelera

OnFwd(OUT_C, 72);

while (true)

{

if(Sensor(IN_1) < umbral)

 {

    OnFwd(OUT_A, 79);

    OnRev(OUT_C, 72);

    Wait(200);

    OnFwd(OUT_A, 79);

    OnFwd(OUT_C, 72);

  }

  if(SENSOR_4==1)

  {

    GiroRandom= Random(1800)+500;

    OnRev(OUT_A, 79);

    OnRev(OUT_C, 72);

    Wait(500);

    PlayTone(4000, 500);

    Off(OUT_AC);

    Wait(2000);

    NumOut(50, 60, numero--); //Cuenta bombas

    OnFwd(OUT_A, 79);

    OnRev(OUT_C, 72);

    Wait(GiroRandom);

    OnFwd(OUT_A, 79);

    OnFwd(OUT_C, 72);

    contador++;

    ClearScreen ();

    }

    if(contador==4)

    {

    OnRev(OUT_A, 79);

    OnFwd(OUT_C, 72);

    Wait(2000);

    PlayTone(4000, 1000);

    OnFwd(OUT_A, 79);

    OnFwd(OUT_C, 72);

    if(Sensor(IN_1) < umbral)

    Off(OUT_AC);

    Wait(1000);

    OnRev(OUT_A, 79);

    OnFwd(OUT_C, 72);

    PlayTone(5000,3000);

    Wait(2500);

    StopAllTasks();

    }

   }

 }

....Bueno, en este código, lo que intento explicar es muy simple, if(Sensor(IN_1) < umbral).....

El robot realiza otras tareas como contar numero de explosivos detonados. Pero mi intención es mostrar que todas las sentencias pueden ser utilizadas simplemente y también con condiciones para que pueda realizar otra tarea.

Reflexión

En la programación, cada código que sea realizado con intención y minuciosamente, sera innovador, y a su vez mientras mas simple sea mejor sera, ya que para todos lo que salga mas fácil y bonito es lo mas llamativo.

Espero que les haya gustado mi ejemplo y como lo explique, cualquier consulta o queja >.<, no duden en escribirme. 

Hasta luego y como se acerca navidad, Feliz navidad y prospero año nuevo :).

Problema Fibonacci(Solución simple)

Autor: Carlos Alberto San Martín San Román
Universidad Católica de Temuco.

Creatividad e innovación

Nivel 1: Identifica respuestas novedosas para resolver mejor las demandas del entorno cotidiano.

Muchas soluciones a problemas, pueden ser solucionados de manera amplia, con grandes códigos y muchas trabas. Pero, lo creativo e innovador, es poder realizar el mismo resultado que aquellos grandes códigos  con otros sencillos y prácticos.

Problema Fibonacci

Genere una solución para el problema de imprimir los N primeros términos de la

serie de Fibonnaci en orden inverso al considerado normal, usando un arreglo de enteros

para almacenar los valores ordenados inversamente. Cree un método al cual se le ingrese el

número de términos y devuelva un arreglo con los elementos de la serie en orden inverso.

La serie de Fibonnaci es aquella en la cual se genera el siguiente término como el resultado

de la suma de los dos anteriores, por ejemplo:

0,1,1,2,3,5,8,13,... Fi := Fi-1 + Fi-2

En este problema el usuario ingresa la cantidad de N dígitos que desea visualizar de la serie,

en orden inverso, y la aplicación imprime el arreglo devuelto por el método.

Ejemplo:

3 → [P] → 1,1,0

5 → [P] → 3,2,1,1,0

Análisis del problema

Fib[i]=Fib[i-1]+Fib[i-2] → de la suma de los dos numeros anteriores resulta el nuevo

                                            valor...

                   Se sabe de la serie fibonacci que los primeros dos valores son el '0' y el '1'...

                                                                                                            Fib[0]=0; Fib[1]=1;

entonces como continuación 'i' de Fib[i] equivale a

                                                                                   '2'

(el espacio '2' equivale a los espacios '2-1' + '2-2')

Fib[2]=Fib[1]+Fib[0] → 1

Sabiendo los datos descritos se puede utilizar un for en el cual el contador

es el espacio del arreglo.

Fib[i]=Fib[i-1]+Fib[i-2] → → → → for(i = 2; i < num; i++)

                                                                fib[i] = fib[i-1] + fib[i-2];

Con esta simple ecuacion logramos obtener la serie fibonacci y guardarla en un arreglo,

pero aun queda invertir esta...

numero = numero igresado por el usuario.

Si el numero ingresado es mayor a 0, generamos un nuevo array para guardar los

datos de fib[] inversamente.

Relacionamos el array con el metodo utilizado para obtener la serie, y utilizamos un for

que nos entregara los valores al reves.

              for(espacioarray = numero-1; espacioarray >= 0; espacioarray--)

                        System.out.print(fibinv[espacioarray] +", ");

Código del programa

package Fibonacci;

//paquete al que pertenece la clase.

/**

* @author carlos

*/

import java.util.Scanner;

por teclado.

//Libreria utilizada, en este caso Scanner para ingresar datos

public class Fibonacciinverso {

int [] fibonacci (int num){

//comienzo clase

//iniciar el metodo, en este caso llamado “fibonacci”.

int[] fib = new int[num];

//iniciar arreglo donde guardaremos la serie

fibonacci.

int i; //variable que utilizaremos como contador y que daremos las

posiciones al arreglo.

fib[0] = 0;

//Se entrega valor a la posicion 0 del arreglo, la cual ya

sabemos y nos sirve de base.

fib[1] = 1;

//Se entrega valor a la posicion 1 del arreglo, la cual ya

sabemos y nos sirve de base.

for(i = 2; i < num; i++)

//ciclo que nos entrega la serie fibonacci.

(iniciamos del espacio 2 del arreglo por lo que “i=2”)

fib[i] = fib[i-1] + fib[i-2];

//Serie fibonacci, sabemos que fib 'c' = fib

'b' + fib 'a', esto lo interpretamos de esta forma en el arreglo.

return fib;

}

//valor que retorna el metodo fibonacci.

//fin del metodo fibonacci.

public static void main(String[] args) throws Exception

solucion de exepciones.

//comienzo main con

int numero; //creamos variable cuyo valor sera ingresado por teclado

int fibinv[];

orden inverso.

//creamos arreglo que utilizaremos para entregar la serie fibonacci en

Try{ //comenzamos try que sera lo que se ejecutara si no existe alguna exepcion

del programa.

System.out.println("Numero entero que se pasara a fibonacci:");

donde pedimos al usuario que ingrese un valor

//texto

Scanner ningresado = new Scanner(System.in);

//iniciamos Scanner

que nos permite escribir por teclado y a su vez entregarle un valor a una variable

numero = ningresado.nextInt();

if(numero==1)

//le damos valor a la variable numero

//iniciamos if, si el numero ingresado es igual a 1

System.out.println("0, serie inversa del valor 1.");

else

//imprimimos

//sino lo es

if (numero > 0){

//iniciamos if, si el numero ingresado es mayor a 0

int espacioarray;

//creamos variable que sera la posicion en el

arreglo

Fibonacciinverso clase = new Fibonacciinverso();

fibinv = clase.fibonacci(numero); //decimos que “fibinv” sera igual al

resultado del metodo utilizando “numero” (numero en el metodo sera el valor de num)

for(espacioarray = numero-1; espacioarray >= 0; espacioarray--)

//iniciamos un for donde decimos que el espacio de partida sera el ultimo espacio

del arreglo, y de este desendera hasta que el espacio sea igual a 0

System.out.print(fibinv[espacioarray] +", ");

//imprimimos los

valores obtenidos del arreglo, que seran inversos al orden del metodo utilizado.

System.out.println("serie inversa del valor " +numero +"."); //imprimir

} //fin del 'if'

else //si el valor no es mayor que 0

System.out.println("el entero debe ser mayor que 0");//imprimir

}

// fin del try

catch(Exception e){

//si se presenta alguna exepcion

System.out.println("Se ha ingresado un valor erroneo");

}

//fin del catch

finally {

//se finaliza el programa al haber exepcion o al cumplirse el proseso

del try

System.out.println("");

}

//imprimir

//fin del finally

} //fin del main

}//fin de la clase

Reflexión

La creatividad e innovación, llevan a la gente a ser mas, y no estancarse en lo cotidiano, ya que este cambio es positivo y atractivo para otras personas.

Espero que este método, que es uno de los mas cortos para la solución(ya que son pocas lineas de código de este).

Cualquier consulta escribirme. Hasta Luego.

Gestión del conocimiento: Diseño de clases java.

Autor: Carlos Alberto San Martín San Román
Universidad Católica de Temuco.

Gestión del conocimiento

Nivel: 1. Reconoce las habilidades y/o procesos cognitivos con los cuales puede identificar, seleccionar, relacionar e interpretar información básica relacionada con su profesión futura.

Programación I: Diseño de clases java, obteniendo avances y adquiriendo el conocimiento de lo que sera parte de mi futura profesión.

Java, ejecutando programas como Netbean's, Eclipce, Bluej, nos permite realizar soluciones a todo tipos de problemas de la vida común, y estas soluciones, entre las mas simples están las que se ejecutan por terminal y las que se ejecutan en ventanas(Swing). También este lenguaje nos da facilidades como las de tener en ficheros separados lineas de códigos funcionales, como los métodos.

Estos o otros rasgos nos dan un buen diseño de clases.

Diseño de clases:

Bueno, aquí les entrego un código java, que esta separado en métodos en distintos ficheros, entre otras cosas, esto nos da un buen diseño de clases(para un primer semestre del primer año de universidad), espero que les sirva de ejemplo...

En esta clase van métodos en una clases, que se utilizan en otra clase, ustedes entenderán.

Clase programa (Clase que llama los métodos)

public class Programa {

    public static void main(String[]args){

        Calculadora ca1, ca2;

        ca1= new Calculadora();

        ca2= new Calculadora(10.5,20.6);

        System.out.println("ca1= "+ca1.getvalor1()+","+ca1.getvalor2());

        System.out.println("ca2= "+ca2);

        System.out.println("la multiplicacion de ca2= "+ca2.getmultiplicar());

        ca1.setvalor1(30);

        ca1.setvalor2(49);

        System.out.println("nuevo ca1= "+ca1);

        System.out.println("la suma de ca1= "+ca1.getsuma());

        System.out.println("la resta de ca2= "+ca2.getresta());

        System.out.println("el modulo de ca2= "+ca2.getmodulo());

        System.out.println("la division de ca1= "+ca1.getdividir());

        System.out.println("El numero mayor de ca2= "+ca2.getmayor());

 }

}

Clase Calculadora (clase con metodos)

public class Calculadora {

    private double valor1, valor2;

    Calculadora(){valor1=0; valor2=0;} //constructor

    Calculadora(double v1, double v2){valor1=v1; valor2=v2;} //metodo del objeto que es llamado....

     double getsuma(){return valor1+valor2;}

     double getresta(){return valor1-valor2;}

     double getmultiplicar(){return valor1*valor2;}

     double getmodulo(){return valor1%valor2;}

     double getdividir(){return (int) valor1/(int)valor2;}

     double setvalor1(double va1){return valor1=va1;}

     double setvalor2(double va2){return valor2=va2;}

     double getvalor1(){return valor1;}

     double getvalor2(){return valor2;}

    public String toString()

 {return valor1+","+valor2;}

 double getmayor(){

     if(valor1>valor2)

       return valor1;

     else

       return valor2;

 }

}

Reflexión

Todos los lenguajes de programación nos permiten distintas cosas que nos dan soluciones a nuestros problemas, como lo son los métodos en java. Esto relacionado a la gestión del conocimiento nos ayuda bastante, ya que en el futuro, nuestro trabajo, para un programador o ingeniero en informática es necesario saber estas formas para diseñar aplicaciones y otras.

Espero que esto les sea de ayuda, cualquier consulta me escriben, hasta luego.

Intro. Base de datos: Póster "Select Avanzado"

Autor: Carlos Alberto San Martín San Román
Universidad Católica de Temuco.

(Mysql, Select advanced, grupal)

Trabajo en equipo

Nivel 1: Reconoce en sí mismo y los demás integrantes de su equipo de trabajo, las fortalezas y debilidades que les permitirán desarrollar una tarea de forma exitosa, comprometiéndose individualmente en acciones vinculadas al logro de los objetivos planteados.

Introducción a las bases de datos: Desarrollar un póster en grupo, que muestre como funciona el "select advanced" en Mysql. De forma que este sea fácil de comprender para cualquier individuo. Esto, relacionado con lo aprendido en clases y en el libro "Head first Mysql".

______________________________________________________________________________

Póster "Select Advanced"

Junto con el grupo semestral en introducción a las bases de datos, se realizo, un sencillo póster que muestra la función de esta sentencia mysql, como se presenta y la sintaxis que utiliza(explicando cada una de sus partes).

(Pinchar en la imagen para descargar el pdf del póster completo)

Función del "select advanced"

Esta forma de seleccionar nos permite trabajar de una forma mas

detallada, la cual nos da la posibilidad de seleccionar con varias

condiciones además de modificar varios detalles de la tabla en una sola

selección

Fragmento del póster

(Las sintaxis y explicaciones de cada palabra son explicadas en el póster)

Integrantes del grupo: Daniel Gutierrez, Jorge Henriquez, Camilo Friz, Carlos San Martín.

Reflexión

Este trabajo fue realizado en grupo, con la intención de explicar cada aspecto de la sentencia "select advanced" que muchas veces en libros extensos como "Head first mysql" son explicados de manera muy engorrosa.

Y nuevamente detallo, que un ingeniero, o cualquier persona con cualquier profesión debe saber trabajar en grupo o colaborar con otras personas para que su negocio prospere.

 De esta manera me despido, cualquier cosa, consulte. Hasta luego.

Programación II: Resolución de ejercicios matemáticos.

Autor: Carlos Alberto San Martín San Román
Universidad Católica de Temuco.

(Java, matemáticas, ciclos anidados)

Trabajo en equipo

Nivel 1: Reconoce en sí mismo y los demás integrantes de su equipo de trabajo, las fortalezas y debilidades que les permitirán desarrollar una tarea de forma exitosa, comprometiéndose individualmente en acciones vinculadas al logro de los objetivos planteados.

Programación II: Resolución de ejercicios matemáticos mediante aplicaciones en lenguaje Java.

Mediante trabajo grupal, reconocemos el problema, buscamos la solución a este y desarrollamos el código del software utilizando ciclos anidados.

__________________________________________________________________________________

Integrantes: Carlos San Martín, Daniel Gutierrez.

Problemática

Calcule la siguiente expresión para un N (N>0) ingresado por el usuario...

Ejemplo: 6 -> [P] -> (1/2)+(1/2*2/2)+(1/2*2/2*3/2)+........+(1/2*2/2*3/2+4/2*5/2*6/2)

Análisis del problema

'I' es un contador, el cual termina cuando el valor es igual a 'N'... La ecuación trabaja con sumatoria y productorio, los que se ejecutan uno, antes que el otro, por lo que es necesario trabajar con ciclos anidados. Esta ecuación trabaja como se ve en el ejemplo.

Código de la solución(Terminal)

                          import java.util.*;

                          public class expresion
                          {
                                public static void main()
                                {
                                      double n;
                                      double e=1;
                                       double nn;
                                      double i;
                                      double j;
                                      Scanner leer = new Scanner(System.in);
                                      System.out.println("ingrese valor a N (N debe ser mayor a 0)");
                                      n=leer.nextDouble();
                                      // System.out.println(n);
                                      nn=0;
                                      while(e<=n){
                                             i=2;

                                             j=0.5;
                                             while(i<=e){
                                                       j *= i/2;
                                                       i++;

                                             }
                                             nn += j;
                                             e++;
                                      }
                                System.out.println(nn);
                                }
                          }

El codigo trabaja la ecuación gracias a los dos ciclos "while" que están anidados.

Reflexión

Para obtener resultados de desarrollo de software orientadas a distintas problemáticas, es necesario reconocer y analizar estas, para luego empezar a programar, y a su vez, trabajando de forma grupal, es posible obtener mayores avances, por lo que es muy recomendable.

Esto es todo, cualquier consulta del código o algún detalle para analizar un problema, estaré atento a sus preguntas. Hasta luego.