PROGRAMACIÓN BÁSICA Reporte Unidades 6, 7, 8 Félix 07/06/2013

1

Presentación

REPORTE

PROGRAMACION BASICA

Unidad VI Y VII

MODULOS Y GRAFICACIÓN

Catedrático:

LIC. Edgar Hernández García

Alumno:

Félix González Bonilla

2

INDICE Introducción a funciones 4

Aproximación al número “e” 5

Factorial de un número 7

Suma de 2 vectores 9

Operaciones básicas de matrices 11

Conclusión 17

Introducción a gráficos 18

Ventana 19

Primitivas 2D 20

Líneas y puntos 20

Polígonos 21

Circulo 24

Líneas 26

Hexágono regular inscrito 28

Polígonos 29

Función seno y coseno 32

Tablero de ajedrez 34

Conclusión 36

Practica Puerto Paralelo 37

Conclusión 38

1

INTRODUCCIÓN A FUNCIONES

En la unidad 6 llamada módulos (funciones o procedimientos) se trabajó con funciones. Una

función es un bloque de instrucciones que se les asigna un nombre. Podría decirse que son

semejantes a programas que estandarizan tareas que son repetitivas, es un fragmento de código

que realiza una tarea bien definida, de debe dejar en claro que las funciones solo son capaces de

devolver un solo dato después de realizar su trabajo, la sintaxis para declarar un función es la

siguiente.

Tipo_DatoNomb_Func(Tipo_Dato Arg 1, Tipo_Dato Arg 2,… Tipo_Dato Arg n);

{

Instrucción 1

Instrucción 2

Instrucción n

Return dato

};

Se debe dejar en claro que el argumento es necesario para realizar la función.

Existen diversos tipos de funciones, en este curso solo vimos una pequeña introducción a las

funciones tocando el tema de procedimientos. Los procedimiento son semejantes a las funciones,

pero a diferencia de las funciones, es que los procedimientos son capaces de devolvernos datos en

variables específicas, la sintaxis para declarar un procedimiento es la siguiente.

Void Nom_Proc(Tipo _Dato Arg 1, Tipo _Dato Arg 2,… Tipo _Dato Arg n);

{

Instrucciones

};

A continuación se presentan algunas prácticas y trabajos pasados realizados con funciones y

procedimientos.

2

Aproximación al número “e”

Código:

using namespace std; double euler(int fac, int s); int main(int argc, char *argv[]) { int pot, sum; double res; cout<<"programa que calcula la serie de Maclaudi"; cout<<"\ningrese la potencia: "; cin>>pot; cout<<"\ningrese el numero de sumas "; cin>>sum; res=euler(pot, sum); cout<<"\nresultado: "<<res<<endl; system("PAUSE"); return EXIT_SUCCESS; } double euler(int fac, int s) { if(fac==0) { return 1; } else { double factorial=1, potencia, resultado; double serie=1; for(int i=1; i<=s; i++) { factorial=factorial*i; potencia=pow(fac,i); serie=serie+(potencia/factorial); } return serie; } }

3

Consola:

Como se puede observar en el programa en ejecución el numero e elevado a la potencia 2, el resultado exacto es 7.38905, sin embargo en el programa nos arroja 7.26667, que es un valor aproximado a el valor real, como veremos si ocupamos el mismo exponente pero con un número mayor de sumas realizadas en la serie, la sumatoria se aproxima más al resultado real, como lo podemos ver en la siguiente imagen.

En este caso 7.35556 se aproxima más a 7.39905.

4

Factorial de un número Código: using namespace std; int factorialx(int n); int main(int argc, char *argv[]) { cout<<"programa que calcula el fectorial de un numero mediante una funcion"; int x, xfactor; cout<<"\n\nIntrodusca el dato para el factorial: "; cin>>x; xfactor=factorialx(x); cout<<"\n\n"<<x<<"!="<<xfactor<<endl; system("PAUSE"); return EXIT_SUCCESS; } int factorialx(int n) { if(n==0 || n==1) { return 1; } else { int fac=1; for(int i=1; i<=n; i++) { fac*=i; } return fac; } }

5

Consola:

6

Suma de 2 vectores Código: #include <cstdlib> #include <iostream> using namespace std; void lee_vec(int orden, int vecA[]); //se declara el procedimiento void Suma_Vec(int i, int vec1[], int vec2[], int re[]); int main(int argc, char *argv[]) { cout<<"\n\n\t\t\tPrograma que calcula la suma de 2 vectores"; cout<<"\n\nLos vecteres deven tener las mismas dimenciones"; int t; cout<<"\nIntroduzca el orden (tamaño) de los vectores: "; cin>>t; int A[t], B[t], R[t]; //se declaran los arreglos despues de tener su valor cout<<"\nIntrodusca los datos del vector A: "<<endl; lee_vec(t,A); cout<<"\nIntrodusca los datos del vector B: "<<endl; lee_vec(t,B); cout<<"\n\n\t\tEl resultado de la suma es: "<<endl; Suma_Vec(t, A, B, R); cout<<endl; system("PAUSE"); return EXIT_SUCCESS; } void lee_vec(int orden, int vec[]) { for(int i=0; i<orden; i++) { cout<<" Posicion ["<<i+1<<"]= "; cin>>vec[i]; }; for(int i=0; i<orden; i++) { cout<<vec[i]<<"\t"; } }

7

void Suma_Vec(int i, int vec1[], int vec2[], int re[]) { for(int j=0; j<i; j++) { re[i]=vec1[j]+vec2[j]; cout<<"\t"<<re[i]; } cout<<endl;

Consola:

8

Operaciones básicas de matrices Código: using namespace std; void guarda(int fil, int col, int matriz[100][100]); void muestra(int fil, int col, int matriz[100][100]); void suma(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100]); void resta(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100]); void producto(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100]); int main(int argc, char *argv[]) { int f, c, ff, cc; cout<<"\n\n\t\tPrograma que realiza operaciones basicas de matrices"; cout<<"Nombrando A y B a las matrices realize lo siguiente "<<endl; cout<<"\nFilas de A: "; cin>>f; cout<<"columnas de A: "; cin>>c; cout<<"\nFilas de B: "; cin>>ff; cout<<"columnas de B: "; cin>>cc; int A[100][100], B[100][100], R[100][100]; cout<<"\n\tIngrese los datos de A: "<<endl; guarda(f, c, A); cout<<"\n\tLa matriz A es: "<<endl; muestra(f, c, A); cout<<"\n\tIngrese los datos de B: "<<endl; guarda(ff, cc, B); cout<<"\n\tLa matriz B es: "<<endl; muestra(ff, cc, B); char opcion; do { cout<<"\n\n\t\tAhora elija una opcion"<<endl; cout<<"A) Suma A + B"<<endl; cout<<"B) Resta A - B"<<endl; cout<<"C) Resta B - A"<<endl; cout<<"D) Producto A * B"<<endl; cout<<"E) Producto B * A"<<endl; cout<<"X) Para salir "<<endl; cin>>opcion; switch(opcion) {

9

case 'A': cout<<"\n\n\tLa suma A + B es: "<<endl; suma(f, c, ff, cc, A, B, R); break; case 'B': cout<<"\n\n\tLa resta A - B es: "<<endl; resta(f, c, ff, cc, A, B, R); break; case 'C': cout<<"\n\n\tLa resta B - A es: "<<endl; resta(ff, cc, f, c, B, A, R); break; case 'D': cout<<"\n\n\tEl producto A * B es:"<<endl; producto(f, c, ff, cc, A, B, R); break; case 'E': cout<<"\n\n\tEl producto B * A es: "<<endl; producto(ff, cc, f, c, B, A,R); break; default: cout<<"\n\n\t\tOpcion no valida intente de nuevo"<<endl; } } while(opcion!='X'); cout<<"\t\t\t\tFIN DEL CILCLO GRACIAS"<<endl; system("PAUSE"); return EXIT_SUCCESS; } void guarda(int fil, int col, int matriz[100][100]) { for(int i=0; i<fil; i++) { for(int j=0; j<col; j++) { cout<<"El dato ["<<i+1<<","<<j+1<<"] es: "; cin>>matriz[i][j]; } } } void muestra(int fil, int col, int matriz[100][100]) { for(int i=0; i<fil; i++) { cout<<"\n"; for(int j=0; j<col; j++) { cout<<"\t"<<matriz[i][j]<<"\t";

10

} } } void suma(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100]) { if(f==ff && c==cc) { for(int i=0; i<f; i++) { cout<<"\n"; for(int j=0; j<c; j++) { MR[i][j]=MA[i][j]+MB[i][j]; } } muestra(f, c, MR); } else cout<<"\n\tLo siento operacion no valida"<<endl; } void resta(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100]) { if(f==ff && c==cc) { for(int i=0; i<f; i++) { cout<<"\n"; for(int j=0; j<c; j++) { MR[i][j]=MA[i][j]-MB[i][j]; } } muestra(f, c, MR); } else cout<<"\n\tLo siento operacion no valida"<<endl; } void producto(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100]) { if(c==ff) { int k; for(int i=0; i<f; i++) { for(int j=0; j<cc; j++) { MR[i][j]=0;

11

for(k=0; k<c; k++) { MR[i][j]=MR[i][j]+(MA[i][k]*MB[k][j]); } } } muestra(f, cc, MR); } else cout<<"\n\n\t\tLo siento operacion no valida"; }

Consola

12

13

14

Conclusión Las funciones y/o procedimientos son como programas pequeños que solo realizan una determinada acción y pueden ser llamados por el programa principal en más de una ocasión, son de gran utilidad al momento de realizar programas extensos, las funciones nos facilitan procesos dentro del programa principal, solo basta indicar su nombre dentro del programa principal e indicar los argumentos con los que va a trabajar, y la función realiza su trabajo. Algunos nos parecen que son difíciles de entender para trabajar con ellos, pero lo que es un poco complejo es tener bien definidos los argumentos de la operación que se desea realizar. Es importante mencionar una experiencia que tuve la primera vez que programe operaciones básicas con matrices sin ayuda de funciones, me resulto un código demasiado grande, cuando lo volví a realizar este mismo programa, pero esta vez utilizando procedimientos, pude notar que mi código principal se redujo demasiado, esto es de mucha ayuda porque ayuda a entender mejor el código y se reduce el espacio de memoria que se ocupa. Se observó que pueden existir funciones dentro de otras, las llamadas funciones anidadas. Esto lo aplique al escribir el código que realiza operaciones básicas de matrices, en este programa declare un procedimiento que mostrara en pantalla las matrices ingresadas por el usuario, este mismo procedimiento muestra las matrices que resultan de las operaciones, este procedimiento está dentro de cada procedimiento que realiza una operación. Elegí escribir el código de esta forma porque al llamar el procedimiento dentro de main no existen los argumentos para el resultado que tiene la matriz que resulta.

15

Introducción a gráficos Introducción Es importante saber cómo elaborar las instrucciones para que el monitor nos muestre una ventana, para ello se requiere de modos para un ambiente gráfico, y ciertas características como son resolución, color, modo grafico etc. Los elementos de un ambiente grafico son:

Hardware *Adaptador grafico *Monitor *Dispositivo de entrada y salida Software *GUI Graphical User Interface *API Aplication Programming Interface *Aplicaciones

Al momento de programar gráficos en c++, se usara la librería <GL/glut.h> , para poder graficar, dentro de la función principal primero se deben segur los siguientes pasos:

1) Iniciar la librería glut. 2) Iniciar el modo de despliegue 3) Iniciar el tamaño indicado en pixeles 4) Indicar la posición de la pantalla recordando que va hacer acomodada desde la esquina

superior izquierda a la distancia medida en pixeles 5) Asignar un nombre a la ventana, crear la ventana 6) Indicar la función de desplegado y llamar a la función encargada de dibujar 7) Indicar la instrucción que le indica al display que vuelva a redibujar el miso dibujo

En resumen estos son los pasos dentro del Main para dibujar. El siguiente código es un ejemplo de cómo crear una ventana

16

Ventana. Código using namespace std; void dibuja(void) { glClear(GL_COLOR_BUFFER_BIT); glFlush(); } int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); glutInitWindowSize(640,380); glutInitWindowPosition(100,100); glutCreateWindow("ventana"); glutDisplayFunc(dibuja); glutMainLoop(); return 0; }

Consola

17

Primitivas 2D

Existen otras instrucciones importantes que definen diferentes cosas y son necesarias y de gran utilidad para poder darle otras características a nuestro programa, algunas son: glClearColor(R,G,B,A); Esta instrucción establece el color con el que será limpiada la pantalla. glMatrixMode(GLenum Mode); Instrucción que establece como se van a proyectar las cosas en un pixel, nosotros usaremos el modo (GL_PROJECTION) glLoadIdentity(); Instrucción que carga una matriz identidad dentro de la matriz de pixeles, en pocas palabras limpia el buffer, gluOrtho2D(Izquierda,Derecha, Abajo,Arriba); Instrucción que selecciona una proporción de la ventana, esta proporción es la que se muestra en la ventana.

Líneas y Puntos

Llamamos primitivas 2D a las instrucciones de callbacks que permiten trazar sobre nuestra pantalla o consola. Para poder trazar puntos se utiliza callbacks GL_POINTS. Para iniciar se indica: glBegin(GL_primitiva); vértice 1 vértice 2 glEnd(); //para terminar. Los vértices se denominan atravez del comando glVertex que tiene diversas variantes glVertex2iv(…); Donde:

gl -Indica la librería Vertex-Es el comando 2 -Es el numero de argumentos (2= 2D, 3= 3D RGV, 4=coordenadas, Homogéneas/RGBA) I –Es el tipo de dato. V –Formato escalar o vectorial (solo se pone cuando se utilizan vectores)

glPointSize(GL Float Tamaño); Indica el tamaño del punto. glLineWidth(GL Float Ancho); Indica el ancho de la línea. glColor#t&(…); Indica el color de la línea o punto. # -Numero de argumentos.

t –Tipo de dato & -Indica si es un vector o un escalar.

Para poder trazar líneas dentro de nuestro lienzo (ventana) se utilizan otra serie de instrucciones dependiendo del tipo de línea que se quiera trazar, estas son: GL_LIENES Traza una recta individual con vértice de inicio y fin. GL_LINE_STRIP Traza varias rectas, todas conectadas, una detrás de otra. GL_LINE_LOOP Traza varias líneas rectas, considerando que el conjunto forma un objeto cerrado ( Tenerse en mente la cantidad de vértices).

18

Polígonos

También existen instrucciones que nos facilitan la creación de figuras geométricas estas se llaman: GL_TRIANGLES Traza superficies triangulares con tres coordenadas desiguales. GL_TRIANGLE_STRIP Genera superficies triangulares, en función de las coordenadas, por ejemplo si se indican cuatro coordenadas se generan 2 triángulos. GL_TRIANGLE_FAN Genera polígonos mediante triángulos empatados pero compartiendo el mismo puto inicial GL_QUADS Genera superficies rectangulares en función de cuatro coordenadas. GL_QUADS_STRIP Genera rectángulos conectados, los primeros cuatro vértices generan un rectángulo, luego cada par de vértices aumentan otro rectángulo. GL_POYGON Genera superficies poligonales en función de la cantidad de coordenadas indicadas glRectf{i}(X1,Y1,X2,Y2) Esta instrucción facilita el trazado de del rectángulo También es importante la declaración de variables de tipo booleano, (lógico, faso) se declaran: GLBoolean variable= Condicion_Logica_Inicial La condición lógica es: GL_True Gl_False A continuación se muestran ejemplos de cómo utilizar estas instrucciones.

19

Puntos Código void inicia(void) { glClearColor(0.0,0.0,1.0,0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,500.0,0.0,500.0); } void dibuja(void) { int vector[]={150,150}; glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.0,0.0,0.0); glPointSize(5); glBegin(GL_POINTS); glVertex2iv(vector); glVertex2i(375,375); for(int i=0; i<=500; i+=20) { glVertex2i(i,250); } for(int j=0; j<=500; j+=20) { glVertex2i(250,j); } glEnd(); glFlush(); } int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); glutInitWindowSize(500,500); glutInitWindowPosition(100,100); glutCreateWindow("puntos"); inicia(); glutDisplayFunc(dibuja); glutMainLoop(); return 0; }

20

Consola

21

Círculo Codigo void inicia(void) { glClearColor(0.0,0.0,0.0,0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,500.0,0.0,500.0); } void circunferencia(void) { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0,1.0,1.0); glPointSize(1); glBegin(GL_POINTS); glVertex2i(250,250); //centro del circulo for(float x=50.0; x<=450.0; x+=0.002) { glVertex2f(x,sqrt(-1*pow(x,2)+500*x-22500)+250); } for(float y=50.0; y<=450.0; y+=0.002) { glVertex2f(y,-1*sqrt(-1*pow(y,2)+500*y-22500)+250); } glEnd(); glFlush(); } int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); glutInitWindowSize(500,500); glutInitWindowPosition(100,100); glutCreateWindow("CIRCUNFERENCIA"); inicia(); glutDisplayFunc(circunferencia); glutMainLoop(); return 0; }

22

Consola

23

Líneas Código void inicia(void) { glClearColor(0.5,0.5,0.5,1.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,500.0,0.0,500.0); } void dibuja_linea(void) { int vec[2][2]={{150,150},{350,350}}; float vecc[]={0.0,1.0,0.0}; glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.0,0.0,0.0); glLineWidth(1.0); glBegin(GL_LINES); glVertex2i(150,350); glVertex2i(350,150); for(int i=0; i<2; i++) { glVertex2iv(vec[i]); } glEnd(); glColor3f(1.0,0.0,0.0); glLineWidth(4.0); glBegin(GL_LINE_STRIP); for(int i=0; i<=10; i++) { glVertex2i(i*50,75+25*pow(-1,i)); } glEnd(); glColor3fv(vecc); glLineWidth(4.0); glBegin(GL_LINE_LOOP); glVertex2i(150,370); glVertex2i(350,370); glVertex2i(350,445); glVertex2i(250,500); glVertex2i(150,445); glEnd(); glFlush(); } int main(int argc, char *argv[]) { glutInit(&argc, argv);

24

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); glutInitWindowSize(500,500); glutInitWindowPosition(250,200); glutCreateWindow("LINEAS"); inicia(); glutDisplayFunc(dibuja_linea); glutMainLoop(); return 0; }

Consola

25

Hexágono regular inscrito Código: void inicia(void) { glClearColor(0.0,0.0,0.0,0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,500.0,0.0,500.0); } void circunferencia(void) { glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0,1.0,1.0); glPointSize(2); glBegin(GL_POINTS); glVertex2i(250,250); //centro del circulo for(float x=50.0; x<=450.0; x+=0.002) { glVertex2f(x,sqrt(-1*pow(x,2)+500*x-22500)+250); glVertex2f(x,-1*sqrt(-1*pow(x,2)+500*x-22500)+250); } glEnd(); int hexa[6][2]={{50,250},{150,80},{350,80},{450,250},{350,420},{150,420}}; glColor3f(0.5,1.0,0.5); glBegin(GL_POLYGON); for(int i=0; i<6; i++) { glVertex2iv(hexa[i]); } glEnd(); glFlush(); } int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); glutInitWindowSize(500,500); glutInitWindowPosition(100,100); glutCreateWindow("CIRCUNFERENCIA"); inicia(); glutDisplayFunc(circunferencia); glutMainLoop(); return 0; }

26

Consola

27

Polígonos

Código void inicia(void) { glClearColor(0.0,0.0,0.0,0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,500.0,0.0,500.0); } void poligono(void) { int tri[3][2]={{100,50},{400,50},{250,150}}; int exa[6][2]={{100,250},{250,165},{400,250},{400,400},{250,485},{100,400}}; glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0,1.0,1.0); glLineWidth(3); glBegin(GL_TRIANGLES); for(int i=0; i<=3; i++) { glVertex2iv(tri[i]); } glEnd(); glBegin(GL_POLYGON); for(int i=0; i<6; i++) { glVertex2iv(exa[i]); } glEnd(); glFlush(); } int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); glutInitWindowSize(500,500); glutInitWindowPosition(300,100); glutCreateWindow("POLIGONOS"); inicia(); glutDisplayFunc(poligono); glutMainLoop(); return 0; }

28

Consola

29

Función Seno y Coseno

Código

void inicia(void) { glClearColor(0.0,0.0,0.0,0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,12.56,-2.0,2.0); } void funcion(void) { glClear(GL_COLOR_BUFFER_BIT); glColor3f(0.0,0.0,1.0); glPointSize(1); glBegin(GL_POINTS); glVertex2f(250.0,250.0); for(double i=0; i<640; i+=.001) { glVertex2f(i,sin(i)); } glEnd(); glColor3f(0.0,1.0,0.0); glPointSize(1); glBegin(GL_POINTS); glVertex2f(250.0,250.0); for(double i=0; i<640; i+=.001) { glVertex2f(i,cos(i)); } glEnd(); glColor3f(1.0,0.,0.0); glLineWidth(2); glBegin(GL_LINES); glVertex2i(0,0); glVertex2i(640,0); glEnd(); glFlush(); } int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); glutInitWindowSize(640,480);

30

glutInitWindowPosition(300,200); glutCreateWindow("FUNCION SENO Y COSENO"); inicia(); glutDisplayFunc(funcion); glutMainLoop(); return 0; }

Consola

31

Tablero de ajedrez Código void inicia(void) { glClearColor(0.0,0.0,1.0,0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,400.0,0.0,400.0); } void domino(void) { float blanco[]={1.0,1.0,1.0}; float negro[]={0.0,0.0,0.0}; GLboolean color_blanco=GL_TRUE; int i; glClear(GL_COLOR_BUFFER_BIT); for(i=0; i<400; i+=50) { if(color_blanco) { glColor3fv(blanco); } else { // glColor3fv(negro); } glRecti(i,0,i+50,50); color_blanco=!color_blanco; for(int y=0; y<400; y+=50) { if(color_blanco) { glColor3fv(blanco); } else { glColor3fv(negro); } glRecti(i,y,i+50,y+50); color_blanco=!color_blanco; } } glFlush(); } int main(int argc, char *argv[])

32

{ glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); glutInitWindowSize(400,400); glutInitWindowPosition(200,200); glutCreateWindow("AJEDREZ"); inicia(); glutDisplayFunc(domino); glutMainLoop(); return 0; }

Consola

33

Conclusión Esta unidad me pareció muy interesante al darme cuenta como es el funcionamiento de colores en un aparato electrónico como es la televisión y la computadora entre otros. La forma en que nosotros podemos apreciar una pantalla es muy importante ya que nos muy fácil hacer que una pantalla muestre colores definidos creando una imagen como en el caso del programa que dibuja un circulo, y el que grafica la función seno y coseno. Lo que realmente me parece importante es el saber que al programar un gráfico en una ventana, nosotros no dibujamos directamente sobre la pantalla, nosotros creamos las instrucciones, y las recibe el buffer, él es el encargado de dibujar en la pantalla. Me pareció muy importante, e interesante la creación de gráficos mediante la programación, le da un aspecto estético a los programas.

34

Practica:

En esta práctica se realizó la representación de un registro de memoria (un byte). En la práctica se

simulo al Byte con 8 leds, cada led represento a un bit, en las siguientes imágenes se muestra el

formulario con sus componentes y algunas pruebas de cada botón y direcciones de números.

Formulario

Leds apagados (Byte)

35

Formulario en ejecución

Conclusión

Los Puertos son muy importantes en el manejo de datos, como sabemos existen 2 tipos de

puertos el puerto paralelo y el puerto serial, en esta práctica utilizamos el puerto paralelo, en la

actualidad el solo se usa el puerto serial ya que es el más eficaz que el puerto paralelo, aunque el

puerto paralelo es más rápido para enviar datos requiere de más energía, es por eso que el puerto

serial es el más utilizado. En esta práctica observamos esto al armar el protoboard, se necesitó de

ocho hilos de cable para dar corriente a lo que represento un Byte, si necesitáramos una cantidad

más alta de bytes sería necesario utilizar más hilos de cable.