viernes, 9 de diciembre de 2011

Robot Turista (Programacion De Robots)

Autor: Fernando Meza
Competencia: Creatividad e Inovacion
Palabras Clave: NXC



Introducción 


En nuestra primera actividad tuvimos que hacer un circuito básico donde nuestro robot tiene que realizar un circuito como si fuera un tren de un parque de diversiones  tiene que avanzar y después girar en 90° y también detenerse en tres estaciones por  2 segundos para que los pasajeros tomen fotografisd  , hasta llegar al fin y comenzar la segunda vuelta.


                Actividad del Robot Turista:
  Esta actividad trabaja con el lenguaje NXC, realizando un circuito con estaciones donde debe detenerse por 2 segundos tres veces a distinta distancia también incluye giros de 90 grados hasta volver al inicio. Donde debe ser probada por el robot que construimos en la actividad anterior, y comprobar que las ordenes que le diéramos sean ejecutadas.
También hay que tener en cuenta los factores que influyen en el circuito que realiza el robot gracias a las órdenes hechas en lenguaje NXC.

Estrategia de solución:
                                                               Lo que nuestro grupo hiso para poder llegar a una solución fue ocupando el método de ensayo y error, calculando los tiempos, tomando en cuentas las variables que afectaban el movimiento del robot como la inclinación de la mesa también los obstáculos que debe esquivar, nosotros como grupo decidimos calibrar las velocidades de los dos motores con diferentes potencia en cada uno, ocupando el lenguaje NXC para poder crear el pseudocódigo.
                                                               A través de esta actividad pudimos crear giros de 90 grados hacer que se moviera por cierta cantidad de segundos y luego se detenga en un punto en especifico también, por 2 segundos, creando así el recorrido que nos fue entregado por el profesor  pudo ser completado, incluyendo la llegada al inicio o punto de partida y concluyendo con su programa. Que fue creado por nosotros.
                                                               En nuestro grupo todos participaron con su opinión y conocimiento en el momento de realizar el programa para nuestro robot (lenguaje NXC), también dividimos los trabajos como el de crear y firmar el video, el de realizar las tareas de ayuda como las de buscar las piezas o algún cable que se necesita para poder completar nuestra actividad, también esta nuestra secretaria que nos organiza, y por ultimo esta nuestro programador en jefe que nos dirigía de forma correcta.



Código del Programa:
task main()                                                                                                                                                                        {                                                                                                                                                           Wait(1000);                                                                                                                       OnFwd(OUT_B,75);                                                                                                        
 OnFwd(OUT_C,71);                                                                                                                         Wait(4900);                                                                                                                                      Off(OUT_BC);                                                                                                                                                   Wait(2000);                                                                                                                                      OnFwd(OUT_B,65);                                                                                                                         OnFwd(OUT_C,62);                                                                                                                         Wait(1500);                                                                                                                      
OnRev(OUT_C,0);                                                                                                           
 OnFwd(OUT_B,47);                                                                                                                         Wait(1000);                                                                                                                                                     Off(OUT_BC);                                                                                                                    OnFwd(OUT_B,75);                                                                                                         
OnFwd(OUT_C,72);                                                                                                                         Wait(2000);                                                                                                                                      Off(OUT_BC);                                                                                                                                   Wait(2000);                                                                                                                     
 OnRev(OUT_C,0);                                                                                                             OnFwd(OUT_B,47);                                                                                                                         Wait(1000);                                                                                                                                      OnFwd(OUT_B,75);                                                                                                          
OnFwd(OUT_C,71);                                                                                                                         Wait(3500);                                                                                                                      
OnRev(OUT_B,0);                                                                                                             
OnFwd(OUT_C,25);                                                                                                                         Wait(1000);                                                                                                                     
 OnFwd(OUT_B,55);                                                                                                                         OnFwd(OUT_C,52);                                                                                                                         Wait(1000);                                                                                                                      
OnFwd(OUT_B,27);                                                                                                         
 OnRev(OUT_C,0);                                                                                                                            Wait(1000);                                                                                                                     
 OnFwd(OUT_B,75);                                                                                                          OnFwd(OUT_C,72);                                                                                                                         Wait(2000);                                                                                                                                      Off(OUT_BC);                                                                                                                                    Wait(2000); //ultima estacion                                                                                                                      OnRev(OUT_C,0);                                                                                                           
 OnFwd(OUT_B,50);                                                                                                                         Wait(1000);                        


Conclusiones:
              Gracias al esfuerzo y la disposición que tuvo cada uno de los integrantes del grupo de trabajo pudimos completar satisfactoriamente este laboratorio, No obstante a esto tuvimos una serie de dificultades que sortear en el camino al éxito, Calibración de los giros de los motores no siempre se nos hiso fácil ya que al ser un objeto con distintas constantes y variables que afectan al movimiento de este tuvimos                           más de un dolor de cabeza con estos.
               La otra dificultad que pudimos observar fue la de la superficie que al ser desplazada unos centímetros el robot tubo perdía de precisión en sus giros.
              Pero después de todas estas pruebas de calibración y superficie pudimos llegar al objetivo final que era el recorrido completo.
              Tras esta entretenida experiencia pudimos aprender a familiarizarnos mas con el robot y el lenguaje de programación NXC o NXT que a pesar de verse un poco complejo es un lenguaje que con practica y harta paciencia se comprende perfectamente para poder ser utilizado en cualquier otra experiencia.




Proyecto Final Robot Registrador de Sonido


Autor: Fernando Meza
Competencia: Creatividad e Inovacion
Palabras Clave: NXC,Proyecto final.


Introducción

A pesar de ser necesarios los valores numéricos se requiere además una grafica de lo que está pasando ya que esta facilita enormemente el entendimiento del proceso en su conjunto.
Nuestro robot además de mostrar los valores también registrara en un grafico los valores recopilados por los sensores o por un motor.
            Este proyecto podremos ver la tendencia de un proceso largo (1 hora por ejemplo) sin necesidad de estar revisando la pantalla del NXT y acabar mareados. Ademas resulta entretenido para jóvenes y pequeño que al pegar una palmada y ver registrada gráficamente su aplauso.

Construcción
Parte Mecánica
Para la construcción de este registrador hemos empleado básicamente elementos del kit LEGO y algunos materiales adicionales.
Como materiales adicionales tenemos:
            Un lápiz de pasta que no necesite ejercer presión para escribir.
            Un rollo de papel de máquina registradora (papel de boleta).
            Unas cuantas gomas elásticas.
Los demás materiales los podemos conseguir del kit de robot lego.


Tenemos el sensor de sonido, el cual recibirá la frecuencia del sonido.
Un motor para el avance del papel.
Un motor para el movimiento del bolígrafo.

Cuando el eje del motor gire una vuelta, la cadena avanzará una distancia determinada, diferente según la rueda que pongas. Exactamente igual que el plato de una bicicleta: una pedalada pueden ser pocos centímetros o varios metros.


Cuanto mayor sea el tamaño de la rueda, mas alto serán las alturas dibujadas en la grafica.


Avance del papel

Según la duración del proceso que estamos midiendo, tendremos que ajustar la velocidad de avance del papel, para que el rollo de papel sea suficiente para medir varias frecuencias.
           
También lo podemos expresar a la inversa: ¿cuántos cm de papel corresponden a 1 minuto de medición? Este dato puede ser calculado una vez construido el registrador y servirá para conocer la duración de un determinado evento. Sabiendo esto, se pueden medir los centímetros de un pico de la gráfica con una regla y saber así cuánto tiempo ha durado ese evento (una palmada por ejemplo).

Cuanto más rápido avance el papel, más ancha será la gráfica. Un ejemplo: supongamos que medimos esa palmada a 2 velocidades distintas de avance del papel. La altura del pico será la misma (siempre que la palmada haya sido exactamente igual). Si el papel avanza lento obtendrás (más o menos) la gráfica de la izquierda.       Si el papel avanza rápido, la de la derecha.





El avance del papel se ajusta con la potencia del motor  y con las ruedas dentadas adecuadas. Para que vaya más lento el avance,  ruedas grandes a la izquierda de la imagen y/o pequeñas a la derecha. Por lo general, el avance debe ser bastante lento.



Conclusión
Para poder efectuar este proyecto necesitaremos trabajar fuertemente en las 2 partes de este proyecto, el código y el diseño del proyecto, ya que para el diseño tendremos que calibrar bastante todos los componentes de la estructura.
            Este proyecto lo elegimos como grupo porque nos pareció agradable para poder trabajar con la materia que estamos pasando, multitareas, arreglos, guardas archivos, etc. Encontramos que a simple vista se veía muy estructurado y un diseño llamativo a simple vista.
            Como grupo encontramos que este proyecto será muy llamativo para jóvenes y niños ya que el jugar con la frecuencia de los sonidos y registros gráficos será  un proyecto educativo y entretenido.



Solaris Como caso de Estudio.

Autor: Fernando Meza
Competencia: Gestion del Conocimiento
Palabras Clave: Sistemas operativos, solaris


Sistema operativo Solaris
Introducción

Luego de finalizar la construcción del informe anterior, nos centramos netamente en la fabricación del nuevo trabajo. Al ser mencionado el nuevo sistema operativo en análisis, nos preguntamos cómo sería su funcionamiento, el uso de sus aplicaciones y las configuraciones de algunos de sus procesos. “Solaris”, es una palabra nueva en las bibliotecas de las personas que formaremos parte de la construcción de este informe. Es por esto que para indagar más sobre este Sistema operativo, realizaremos las mismas actividades efectuadas en el informe anterior. Para el caso de que se hayan olvidado, las mencionaremos a continuación:
1. Probar la creación de usuarios y grupos (cada miembro del grupo es un usuario), identificar los distintos grupos de usuario existentes en el sistema e indicar la funcionalidad de cada uno de ellos.

2. Revisar la administración de servicios del sistema (procesos en segundo plano), indicar como se configuran los servicios en el sistema.

3. Revisar los permisos y atributos de archivos: Probar estos permisos y atributos con los usuarios y grupos creados.

4. Revisar y documentar los principales aspectos de la configuración de Red del sistema.

5. Revisar el visor de sucesos y documentar alguno de sus reportes.

Junto con estas actividades, el informe además deberá cumplir una serie de ruquecitos, los cuales serán tomados en cuenta al momento de la evaluación, es por esto que no debe faltar ninguno de ellos. Se define la plataforma en la cual se monto la maquina virtual junto con los requerimientos del sistema. A continuación se especifica el entorno de vitalización, esto quiere decir donde se monto el sistema operativo (Para esta ocasión en la maquina virtual “Virtual Box”). Seguido de esto, una pequeña síntesis con la información más relevante de todo el informe para continuar con el desarrollo. Luego de las respuestas de las actividades (Las cuales van con sus respectivas capturas de pantalla), se finaliza el informe con una conclusión la cual releva un poco los objetivos conseguidos, los aprendizajes logrados y algunos de los puntos más importantes revisados durante el informe. A modo optativo, se pueden colocar algunas referencias sobre las fuentes de información.


Requerimientos Básicos Del Sistema Operativo Solaris
1. 256 MB RAM (ó 512 MB Para PXE booting)
2. 2 GB de espacio disponible en disco.
3. Para procesadores SPARC 250-MHz mínimo
4. Para procesadores x64- o x86 120-MHz mínimo (Checar lista de compatibilidad
Solaris Hardware Compatibility List (HCL))
5. DVD o CD-ROM

Instalación Del Sistema Operativo Solaris (VirtualBox)

Seleccionamos el idioma
Inicio de la instalacion
Seleccionamos la Hora y Fecha.
Creacion Del Usuario Admin
Especificaciones del Sistema
Finalizacion De la instalacion
Probamos la Creacion De grupos
Y añadimos a este usuario a un Grupo
Creamos un nuevo usuario llamado Gabriel al cual le Damos una contraseña

Un grupo es una recopilación de usuarios que pueden compartir archivos y otros recursos del sistema. Por ejemplo, usuarios que trabajan en el mismo proyecto podrían formarse en un grupo. Un grupo es conocido tradicionalmente como un grupo UNIX.
Cada grupo debe tener un nombre, un número de identificación de grupo (GID) y una lista de nombres de usuario que pertenecen al grupo. Un número GID identifica el grupo internamente para el sistema. Los dos tipos de grupos al que un usuario puede pertenecer son los siguientes:  Grupo primario – Específica un grupo que el sistema operativo asigna a archivos creados por los usuarios. Cada usuario debe pertenecer a un grupo primario.  Grupos secundarios – Especifica uno o más grupos a los que los usuarios pueden pertenecer. Los usuarios pueden pertenecer a hasta 15 grupos secundarios. Para obtener directrices detalladas sobre la configuración de nombres de grupo, consulte Directrices para utilizar nombres de usuario, ID de usuario e ID de grupo. En ocasiones, un grupo secundario del usuario no es importante. Por ejemplo, la propiedad de archivos reflejar el grupo primario y no un grupo secundario. Otras aplicaciones, sin embargo, puedan depender de pertenencias a grupos secundarios del usuario. Por ejemplo, un usuario tiene que ser un miembro del grupo sysadmin (grupo 14) para utilizar el software Admintool en las versiones anteriores de Solaris. Sin embargo, no importa si el grupo 14 es su actual grupo primario. El comando groups enumera la lista de grupos a los que pertenece un usuario. Un usuario puede tener solamente un grupo primario a la vez. Sin embargo, un usuario puede cambiar temporalmente el grupo primario del usuario, con el comando newgrp, para cualquier otro grupo del que el usuario es miembro. Al agregar una cuenta de usuario, debe asignar un grupo primario a un usuario o aceptar el grupo predeterminado, staff (grupo 10). El grupo primario ya debería existir. Si el grupo primario no existe, especifique el grupo por número GID. Los nombres de usuario no se agregan a los grupos primarios. Si los nombres de usuario se agregaron a grupos primarios, la lista podría llegar a ser demasiado larga. Antes de poder asignar usuarios a un nuevo grupo secundario, debe crear el grupo y asignarle un número GID. Algunos Grupos de Usuarios Entre otros:
Bin          daemon           listen           lp             noaccess         nobody      nobody4
Nuucp                                                  root



2) Revisar la administración de servicios del sistema (procesos en segundo plano), indicar como se configuran los servicios en el sistema.
Para poder tener un prceso en segundo plano le enviamos una señal para que se detenga y luego otra para que continúe su ejecución. Pero este proceso es incómodo, tenemos una forma más simple de enviar un programa para que se ejecute directamente en segundo plano. Esto es con el operador & tras el nombre del programa y su argumentos. Un ejemplo simple de esta acción sería:
$ sleep 200 &
$ ps
Al lanzar el proceso, nos aparece por pantalla algo parecido a:
[1] 2 035 donde:
[1] es el número de trabajo 2035 es el número de proceso.
Podemos observar como el indicador de la línea de órdenes no aparece inmediatamente. Sin embargo esto no supone que la terminal de salida no sea desde la que se lanzó el proceso; es decir, el proceso seguirá mostrando su salida en la pantalla desde la que dimos la orden de ejecución.
Ahora, a ese proceso en segundo plano podemos enviarle señales con las órdenes kill y killall como hicimos antes.
Ejemplos:
$ sleep 200 &
$ sleep 201 &
$ ps y
podemos observar como los procesos continúan activos.
$ sleep 10 & Ahora esperamos 10 segundos y el sistema nos
avisa que ha terminado.
[3]+ Done sleep 10
3) Los permisos y atributos de archivos: Probar estos permisos y atributos con los usuarios y grupos creados.
Cada permiso definido especifica el acceso que un grupo o un usuario puede tener al directorio o al archivo. Por ejemplo, si establece el permiso de lectura (R) para el grupo denominado Grupotrabajo sobre el archivo MIS_IDEAS.DOC, los usuarios de ese grupo podrán ver los datos y atributos del archivo, pero no modificarlo ni suprimirlo.
Lectura (R) - Permite a los individuos o grupos ver el contenido de una carpeta o un archivo, pero no editarlo, eliminarlo o ejecutarlo.
Escritura (W) - Permite a los individuos o grupos ver y modificar un archivo o el contenido de una carpeta.
Ejecución (X) - Permite a los individuos o grupos ejecutar programas, pero no ver ni editar su código .
Acceso total (RWX) - Permite a los individuos o grupos ver, editar y ejecutar archivos, directorios o programas ejecutables.
Sin acceso (NoAccess) - Deniega cualquier tipo de acceso (se obtiene si no se define ninguno de los permisos anteriores).
Los permisos se establecen sobre los archivos y directorios, pero quienes disfrutan de ellos son los usuarios de los equipos. El entorno operativo Solaris hace distinciones entre los sujetos que poseen los permisos:
Usuario - Si un usuario es propietario de un archivo o un directorio del sistema Solaris, ese usuario puede definir los permisos de acceso a ese archivo o directorio. Por ejemplo, para impedir que usuarios no autorizados ejecuten un programa, puede establecer el permiso de ejecución sólo para sí mismo.
Grupo - En el sistema de archivos Solaris, los permisos de grupo otorgan a otros miembros del grupo Solaris al que pertenece un usuario acceso a los archivos y directorios que son propiedad de ese usuario.
Otros - Un usuario puede asignar permisos de acceso a los archivos y directorios de su propiedad para todos los usuarios del sistema Solaris excepto él mismo y los usuarios de su grupo. En función de las necesidades, puede permitir a esos otros usuarios leer o cambiar sus archivos y directorios o no permitírselo. La restricción del acceso a otros grupos no afecta a su propio acceso a sus archivos y directorio



Configuración de la red
En construcción del acceso a la red intervienen muchos archivos y procesos. Aquí se muestras alguno de los más relevante
El fichero /etc/inet/host
Contiene una lista de entradas en las cuales se asocian direcciones IP con sus nombres de maquinas correspondientes. Un ejempo de fichero es este
# internet host table
127.0.0.1 localhost loghost
156.35.94.1 hall2000
135.12.54.8 mercurio
195.77.66.1 deepblue
Hay que presentar atención si se edita este fichero de forma manual, en no dejar espacios en blanco detrás de nombre de maquina Unix suele ser muy sensible a este tipo de detalles
El fichero etc/defaultdomain
Establece el nombre de nuestro dominio para el servicio de nombres de dominio (DNS)
Ej : hall2000.servidoresmagicos.es
El fichero /etc/nodename
En el almacenamos el nombre de nuestra maquina
Ej : hall2000
El fichero /etc/hostname.xxy y otros ficheros
Aqui se registra la interfaz Ethernet como le0 y almacena el nombre o IP de la maquina
Ej : #cat/etc/hostname.le0
hall2000
#
Otros Ficheros relacionados con la red, son:
/etc/net/ticlts/hosts
/etc/net/ticots/hosts
/etc/net/ticotsord/hosts
Muestra los Procesos en 2do Plano


CONCLUSIÓN
El ambiente del Sistema Operativo Solaris nos brinda algunas características, las cuales nos ayudan a dar una buena portabilidad, estabilidad, compatibilidad y seguridad en las aplicaciones para así operar en un ambiente Estable. También presenta características para los usuarios la cual cuenta con ventanas para manejo de servicios rápidos, al igual que integra servicios desktop, bibliotecas gráficas, administración de calendario y herramientas de imagen. Este sistema tiene características para el administrador de sistemas en donde se puede obtener información sobre dispositivos.
El sistema operativo Solaris brinda paquetes de software (colecciones de archivos y directorios) y clusters (colección de paquetes). El kernel de solaris tiene multithread en vez de llave maestra la cual brinda mayor impacto en cómo está diseñado el controlador. Su instalación se basa en 3 formas como los son el salvar la información de la configuración, del sistema de archivo y que hacer antes de instalar un software de Solarios. Este sistema cuenta con comandos los cuales nos ayudarán a manejar el sistema;
Para cualquier duda o consulta sobre Solaris Escribanos y dejenos su opinion u ayuda en el caso de que encuentren alguna mejora para los casos anteriores.


Proyecto robotica (Pitfinder)

Autor: Fernando Meza
Competencia: Trabajo en Equipo
Palabras Clave: NXC



Introducción
Un robot recorre la meseta de una montaña, y su misión es detectar las alturas de los precipicios de ésta, información que servirá para escaladores, paracaidistas, deportes extremos en general.

Implementación

  • La meseta de la montaña estará dada por la mesa de competición sin paredes.
  • Cada vez que el robot detecte el fin de la mesa, deberá detenerse, y medir la altura del “precipicio”. Este dato será registrado y guardado en un ARRAY de enteros.
  • Después de medir, debe (al azar) buscar otro borde de la mesa, y realizar la misma operación.
  • El robot finaliza su trabajo de búsqueda cuando registró la medición del 4to “precipicio”.
  • Finalizada la búsqueda genera un reporte que guardará en un archivo (WriteLnString).. Un ejemplo del formato del reporte sería:

REPORTE PITFINDER
--------------------
Precipicio 1 ==> 20 mts
Precipicio 2 ==> 10 mts
Precipicio 3 ==> 30 mts
Precipicio 4 ==> 20 mts

  • Al final, deberá mostrar en el visor del NXT el reporte de los precipicios anteriormente guardado en el archivo, a través de la lectura del mismo (ReadLnString).

Codigo NXC Para el resultado del Ejercicio.

#define LUZ 40 // Definimos El umbral de luz
#define UMBRAL 80 // Definimos el umbral de sonido
int choque=0 ; // iniciamos el contador choque en 0
int puntonegro=0; // iniciamos el contador puntonegro en 0
int pote=25 ; // iniciamos la potencia inicial en 25
// Motor derecho A
// Motor Izquierdo B
inline int GiroPotencia (int t, string direccion, string evento){ // Inicio del // Parametro
if(evento=="choque" ){  //Si el evento=choque
OnRev(OUT_AB,40); //Avanzar a una potencia de 40
Wait(t); // Esperar tiempo
RotateMotor(OUT_A,40,180); // Rotar el motor girar en 180º Wait(t);} // Esperar un tiempo
if(evento=="puntonegro" ){ // Si evento =punto negro
OnRev(OUT_AB,40); // Avanzar en una potencia de 40
Wait(t);  // Esperar un un tiempo
int Grados;  // Definimos Grados
Grados=Random(180); // Grados= un valor de 0 a 180º
if (direccion=="d" ){  // Si dirección = a d(derecha)
RotateMotor(OUT_B,40,Grados); // Rotar motor B potencia 40 en //Xgrados
Wait(t);}  // Esperar tiempo
else { // En el caso contrario
RotateMotor(OUT_A,40,Grados); // Rotar motor A potencia 49 en //X grados
Wait(t);}
}
} //Terminar parámetro Giropotencia
task main(){
SetSensorTouch(IN_2);  //Sensor de Tacto.
SetSensorLight(IN_3); //Sensor de Luz
SetSensorSound(IN_4); //Sensor de Sonido.
while (Sensor(IN_4)<UMBRAL){ //Entra en el ciclo Sensor sonido>Umbral
OnFwd(OUT_AB,pote); // Avanzar potencia
if(Sensor(IN_2)==1){ // Si sensor Tacto=1
choque++; // Contador choque súmele 1
if(pote>30){ // Si pote >30
pote=pote-10;} // A pote réstele 10
GiroPotencia(1500,"d" ,"choque" ); //GiroPotencia tiempo 1500 //derecha eventochoque
}
if(Sensor(IN_3)< LUZ){ // si Sensor de luz es menor a LUZ
 puntonegro++;  // Contador puntonegro súmele 1
if(pote<100){ // Si pote <100
pote=pote+10;} // pote sumele10
int dir; // Definimos la variable dir
dir=Random(1); // Dir se define en un valor random de d y i
if (dir==1) // Si dir=1
GiroPotencia(1500,"d" ,"puntonegro" ); // GiroPotencia Tiempo //15000 Derecha
else // En el caso contrario
GiroPotencia(1500,"i" ,"puntonegro" ); // GiroPotencia Tiempo //15000 Izquierda
}
} // Termino del main
Off(OUT_AB); //Apagar motores
TextOut(30,50,"puntonegro="); // Coordenadas para mostrar por pantalla
NumOut(50,40,puntonegro); // Los valores expuestos en las variables
TextOut(30,20,"choque"); // De los contadores de Choque y Puntonegro
NumOut(50,10,choques);
Wait(90000) ; // Esperar 90000 milisegundos
} //Termino Del Programa

Conclusión

El objetivo principal fue obtenido correctamente ya que el robot recorrio la meseta de una montaña (mesa de practica) , y su misión fue detectar las alturas de los precipicios de ésta Al final de la mesa avian unos cubos los cuales se trataba de simular la altura de los precipicios, esta información servirá para escaladores, paracaidistas, deportes extremos en general.


capitulo 9 del libro Head First Subconsultas

Autor: Fernando Meza
Competencia: Trabajo en equipo

Palabras Clave: Base de datos, Subconsultas

En este caso Creamos una presentacion en Power point para poder explicar mejor y mas dinamicamente el capitulo 9 esto corresponde a Subconsultas ( y utilizamos El trabajo en equipo)













Conclusión
Como Pudimos observar anteriormente en las diapositivas nos muestran el correcto uso de las subconsultas las cuales nos sirven para acortar y simplificar una consulta dividiéndola en distintos campos .
Espero que les halla servido de mucha utilidad el contenido anterior y para cualquier consulta del tema escribanos y dejenos su post.