jueves, 29 de enero de 2009 0 comentarios

Website y Blog de COECYS

Ya tenemos website y blog oficiales en coecys 2009, se ha puesto la información general del congreso, de las actividades y se está actualizando el blog con todas las actividades que se van haciendo.

Website: www.coecys.com
Blog: www.coecys.com/blog


Te puedes suscribir en el sitio web para recibir los posts del blog por mail, se tiene un contador de visitas y ya se tienen a unos patrocinadores.


Si eres de los que les gusta leer blogs esperamos que nos agregues a tu lector de feeds,

miércoles, 21 de enero de 2009 3 comentarios

Ambulancia Chapina

Un poco de humor no cae mal, les dejo un video de una ambulancia chapina:


sábado, 17 de enero de 2009 7 comentarios

Sólo cuando estás bien contigo puedes estar bien con los demás

He tenido últimamente platicas con amigos sobre las relaciones, en el sentido de que alguien dice : "ve ahora que él tiene novia va a estar feliz" o "deplano ahora va a andar triste todo el tiempo porque corto con su novia" o "que se consiga mujer porque anda triste".

Esto da para hablar pero yo alego cuando me dicen algo así porque uno debe de estar feliz y sentirse bien estando solo o con alguien, de hecho hemos hablado con un amigo mucho sobre esto, que para poder estar listo para una relación uno tiene que disfrutar estar solo, ser felices solos para poder darle esa felicidad a alguien.
No me agrada que alguien busque pareja para aliviar sus males, creo que eso es egoísta y solo se le hace daño a la persona por estar tratando de que "el/ella" nos haga felices, si estamos con alguien es para dar lo mejor de nosotros y buscar hacer a la persona feliz!! no hacernos felices.





Les dejo un artículo del blog de Tito, me gusta mucho y pienso que tiene mucha razón:

  • Sólo cuando estás bien contigo mismo puedes estar bien con los demás.
  • Sólo cuando manejas tu soledad puedes manejar una relación.
  • Necesitas valorarte para valorar, quererte para querer, respetarte para respetar,y aceptarte para aceptar, ya que nadie da lo que no tiene dentro de sí.
  • Ninguna relación te dará la paz que tu mismo no crees en tu interior.
  • Ninguna relación te brindará la felicidad que tu mismo no construyas.
  • Solo podrás ser feliz con otra persona cuando seas capaz de decirle bien convencido: "No te necesito para ser feliz".
  • Solo podrás amar siendo independiente, hasta el punto de no tener que manipular ni manejar a los que dices querer.
  • Solo se podrá ser feliz cuando dos personas felices se unen para compartir su felicidad, no para hacerse felices la una a la otra.
  • Para amar necesitas una humilde autosuficiencia, necesitas autoestima y la práctica de una libertad responsable.
  • Pretender que otra persona nos haga felices y llene todas nuestras expectativases una fantasía narcisista que solo trae frustraciones.
  • Por eso, ámate mucho, madura, y el día que puedas decirle al otro: "Sin ti la paso bien" …ese día estarás más preparado para vivir en pareja.
  • Buscamos una pareja muchas veces para escapar denuestra soledad. No nos sentimos bien estando solos y parece que sin otro ser nuestra vida no tuviera sentido.
  • Para sentirnos valiosos, importantes, y necesarios nos abrazamos a una relación y si esta se rompe nos sentimos morir un poco.
  • ¿Por qué buscamos muletas?
  • ¿Por qué creemos que sólo estando en pareja podemos lograr sentirnos felices?
  • Podemos empezar a trabajar con nuestro interior… Podemos aprovechar nuestra soledad para crecer por dentro… Podemos comenzar de pronto algo que veniamos postergando por falta de tiempo… Podemos…
  • Podemos darnos cuenta que somos importantes, más allá de nuestra pareja.
  • Solo estando bien por dentro podemos atraer a nuestra vida personas valiosas.
  • Nuestra autoestima, se refleja en nuestras compañias y es por eso que muchas veces nos preguntamos porqué estamos al lado de esa persona, por qué nos gobiernan, nos manejan,y hacen con nosotros lo que quieren…
  • Debemos aprender a querernos, a mimarnos, y por sobre todo debemos todos los días agregar una cuota más de amor a nosotros mismos.
  • Para poder amar a otra persona primero tenemos que aprender a amarnos.
martes, 13 de enero de 2009 5 comentarios

Paisajes de Guatemala

Les dejo unos paisajes tomados por un amigo....





0 comentarios

Colas de Mensajes para linux

Las colas de mensajes, junto con los semáforos y la memoria compartida son los recursos compartidos que pone unix a disposición de los programas para que puedan intercambiarse información.

En c para unix se puede hacer que dos aplicaciones se envien mensajes, para ello se usa la cola de mensajes, en ella se envian los mensajes y en la otra aplicación se sacan en el orden en que entraron.
Se envian los mensajes clasificados en tipos, estos son enteros.

Les muestro dos aplicaciones que envían mensajes,

Aplicación 1
ej_cola1.c


#include
#include
#include
#include

// obligatoriamente como primer campo un long para indicar un identificador del mensaje.
// Los siguientes campos son la información que se quiera transmitir en el
// mensaje. Cuando más adelante, en el código, hagamos un cast a
// (struct msgbuf *), todos los campos de datos los verá el sistema como
// un único (char *)

struct Mi_Tipo_Mensaje
{
long Id_Mensaje;
int Dato_Numerico;
char Mensaje[10];
}Un_Mensaje;

int main(void)
{
key_t Clave1;
int Id_Cola_Mensajes;

// Igual que en cualquier recurso compartido (memoria compartida, semaforos
// o colas) se obtien una clave a partir de un fichero existente cualquiera
// y de un entero cualquiera. Todos los procesos que quieran compartir este
// semaforo, deben usar el mismo fichero y el mismo entero.

Clave1 = ftok ("/bin/ls", 33);
if (Clave1 == (key_t)-1)
{
printf("Error al obtener clave para cola mensajes");
return(0);
}

// Se crea la cola de mensajes y se obtiene un identificador para ella.
// El IPC_CREAT indica que cree la cola de mensajes si no lo está.
// el 0600 son permisos de lectura y escritura para el usuario que lance
// los procesos. Es importante el 0 delante para que se interprete en octal.

Id_Cola_Mensajes = msgget (Clave1, 0600 | IPC_CREAT);
if (Id_Cola_Mensajes == -1)
{
printf("Error al obtener identificador para cola mensajes");
return(0);
}

// Se rellenan los campos del mensaje que se quiere enviar.
// El Id_Mensaje es un identificador del tipo de mensaje. Luego se podrá
// recoger aquellos mensajes de tipo 1, de tipo 2, etc.
// Dato_Numerico es un dato que se quiera pasar al otro proceso. Se pone,
// por ejemplo 29.
// Mensaje es un texto que se quiera pasar al otro proceso.

Un_Mensaje.Id_Mensaje = 1;
Un_Mensaje.Dato_Numerico = 29;
strcpy (Un_Mensaje.Mensaje, "Hola");

// Se envia el mensaje. Los parámetros son:
// - Id de la cola de mensajes.
// - Dirección al mensaje, convirtiéndola en puntero a (struct msgbuf *)
// - Tamaño total de los campos de datos de nuestro mensaje, es decir
// de Dato_Numerico y de Mensaje
// - Unos flags. IPC_NOWAIT indica que si el mensaje no se puede enviar
// (habitualmente porque la cola de mensajes esta llena), que no espere
// y de un error. Si no se pone este flag, el programa queda bloqueado
// hasta que se pueda enviar el mensaje.

msgsnd (Id_Cola_Mensajes, (struct msgbuf *)&Un_Mensaje,
sizeof(Un_Mensaje.Dato_Numerico)+sizeof(Un_Mensaje.Mensaje),
IPC_NOWAIT);

// Se recibe un mensaje del otro proceso. Los parámetros son:
// - Id de la cola de mensajes.
// - Dirección del sitio en el que queremos recibir el mensaje,
// convirtiéndolo en puntero a (struct msgbuf *).
// - Tamaño máximo de nuestros campos de datos.
// - Identificador del tipo de mensaje que queremos recibir. En este caso
// se quiere un mensaje de tipo 2. Si ponemos tipo 1, se extrae el mensaje
// que se acaba de enviar en la llamada anterior a msgsnd().
// - flags. En este caso se quiere que el programa quede bloqueado hasta
// que llegue un mensaje de tipo 2. Si se pone IPC_NOWAIT, se devolvería
// un error en caso de que no haya mensaje de tipo 2 y el programa
// continuaría ejecutándose.

msgrcv (Id_Cola_Mensajes, (struct msgbuf *)&Un_Mensaje,
sizeof(Un_Mensaje.Dato_Numerico) + sizeof(Un_Mensaje.Mensaje),
2, 0);

printf("Recibido mensaje tipo 2 \n");
printf("Dato_Numerico = %i \n",Un_Mensaje.Dato_Numerico);
printf("Mensaje = %s \n",Un_Mensaje.Mensaje);


// Se borra y cierra la cola de mensajes.
// IPC_RMID indica que se quiere borrar. El puntero del final son datos
// que se quieran pasar para otros comandos. IPC_RMID no necesita datos,
// así que se pasa un puntero a NULL.

msgctl (Id_Cola_Mensajes, IPC_RMID, (struct msqid_ds *)NULL);
}

Aplicación 1
ej_cola2.c


#include
#include
#include
#include

// Estructura para los mensajes que se quieren enviar y/o recibir. Deben llevar
// obligatoriamente como primer campo un long para indicar un identificador
// del mensaje.
// Los siguientes campos son la información que se quiera transmitir en el
// mensaje. Cuando más adelante, en el código, hagamos un cast a
// (struct msgbuf *), todos los campos de datos los verá el sistema como
// un único (char *)

struct Mi_Tipo_Mensaje
{
long Id_Mensaje;
int Dato_Numerico;
char Mensaje[10];
}Un_Mensaje;


int main(void)
{
key_t Clave1;
int Id_Cola_Mensajes;

// Igual que en cualquier recurso compartido (memoria compartida, semaforos
// o colas) se obtien una clave a partir de un fichero existente cualquiera
// y de un entero cualquiera. Todos los procesos que quieran compartir este
// semaforo, deben usar el mismo fichero y el mismo entero.

Clave1 = ftok ("/bin/ls", 33);
if (Clave1 == (key_t)-1)
{
printf("Error al obtener clave para cola mensajes \n");
return(0);
}

// Se crea la cola de mensajes y se obtiene un identificador para ella.
// El IPC_CREAT indica que cree la cola de mensajes si no lo está.
// el 0600 son permisos de lectura y escritura para el usuario que lance
// los procesos. Es importante el 0 delante para que se interprete en
// octal.

Id_Cola_Mensajes = msgget (Clave1, 0600 | IPC_CREAT);
if (Id_Cola_Mensajes == -1)
{
printf("Error al obtener identificador para cola mensajes \n");
return(0);
}

// Se recibe un mensaje del otro proceso. Los parámetros son:
// - Id de la cola de mensajes.
// - Dirección del sitio en el que queremos recibir el mensaje,
// convirtiéndolo en puntero a (struct msgbuf *).
// - Tamaño máximo de nuestros campos de datos.
// - Identificador del tipo de mensaje que queremos recibir. En este caso
// se quiere un mensaje de tipo 1, que es el que envia el proceso cola1.cc
// - flags. En este caso se quiere que el programa quede bloqueado hasta
// que llegue un mensaje de tipo 1. Si se pone IPC_NOWAIT, se devolvería
// un error en caso de que no haya mensaje de tipo 1 y el programa
// continuaría ejecutándose.

msgrcv (Id_Cola_Mensajes, (struct msgbuf *)&Un_Mensaje,
sizeof(Un_Mensaje.Dato_Numerico) + sizeof(Un_Mensaje.Mensaje),
1, 0);

printf("Recibido mensaje tipo 1 \n");
printf("Dato_Numerico = %i \n",Un_Mensaje.Dato_Numerico);
printf("Mensaje = %s \n",Un_Mensaje.Mensaje);

// Se rellenan los campos del mensaje que se quiere enviar.
// El Id_Mensaje es un identificador del tipo de mensaje. Luego se podrá
// recoger aquellos mensajes de tipo 1, de tipo 2, etc.
// Dato_Numerico es un dato que se quiera pasar al otro proceso. Se pone,
// por ejemplo 13.
// Mensaje es un texto que se quiera pasar al otro proceso.
//
Un_Mensaje.Id_Mensaje = 2;
Un_Mensaje.Dato_Numerico = 13;
strcpy (Un_Mensaje.Mensaje, "Adios");

// Se envia el mensaje. Los parámetros son:
// - Id de la cola de mensajes.
// - Dirección al mensaje, convirtiéndola en puntero a (struct msgbuf *)
// - Tamaño total de los campos de datos de nuestro mensaje, es decir
// de Dato_Numerico y de Mensaje
// - Unos flags. IPC_NOWAIT indica que si el mensaje no se puede enviar
// (habitualmente porque la cola de mensajes esta llena), que no espere
// y de un error. Si no se pone este flag, el programa queda bloqueado
// hasta que se pueda enviar el mensaje.

msgsnd (Id_Cola_Mensajes, (struct msgbuf *)&Un_Mensaje,
sizeof(Un_Mensaje.Dato_Numerico)+sizeof(Un_Mensaje.Mensaje),
IPC_NOWAIT);
}


Para correr los archivos .c se compilan en consola con:
# gcc  ej_sem1.c -o ej_sem1

Y para correrlo:
# ./ej_sem1


Lo mismo con el segundo archivo, se corre cada uno en una consola diferente y veremos como funcionan los semáforos del sistema operativo linux/unix.

Para mayor referencia:
http://www.chuidiang.com/clinux/ipcs/colas.php
1 comentarios

Semáforos para Linux

A veces se tienen varios procesos que deben de usar un recurso compartido, pero si los dos usaran el recurso al mismo tiempo provocarían un problema.
Un semáforo da acceso al recurso a uno de los procesos y se lo niega a los demás mientras el primero no termine. Los semáforos, junto con la memoria compartida y las colas de mensajes, son los recursos compartidos que suministra UNIX para comunicación entre procesos.

Necesito usar semáforos pero que sean del sistema operativo Linux, para ello se usan semáforos desde c.
Pondré un ejemplo de dos procesos que se ejecutan usando los semáforos,


Archivo 1
ej_sem1.c

#include 
#include
#include
#include
#include

// Esta union hay que definirla o no según el valor de los defines aquí indicados.

#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
// La union ya esta definida en sys/sem.h
#else
// Tenemos que definir la union
union semun
{
int val;
struct semid_ds *buf;
unsigned short int *array;
struct seminfo *__buf;
};
#endif

int main(void)
{
key_t Clave;
int Id_Semaforo;
struct sembuf Operacion;
union semun arg;
int i=0;

// Igual que en cualquier recurso compartido (memoria compartida, semaforos
// o colas) se obtien una clave a partir de un fichero existente cualquiera
// y de un entero cualquiera. Todos los procesos que quieran compartir este
// semaforo, deben usar el mismo fichero y el mismo entero.

Clave = ftok ("/bin/ls", 33);
if (Clave == (key_t)-1)
{
printf("No puedo conseguir clave de semaforo\n");
exit(0);
}

// Se obtiene un array de semaforos (10 en este caso, aunque solo se usara uno.
// El IPC_CREAT indica que lo cree si no lo está
// el 0600 con permisos de lectura y escritura para el usuario que lance
// los procesos. Es importante el 0 delante para que se interprete en
// octal.

Id_Semaforo = semget (Clave, 10, 0600 | IPC_CREAT);
if (Id_Semaforo == -1)
{
printf("No puedo crear semaforo\n");
exit (0);
}

// Se inicializa el semáforo con un valor conocido. Si lo ponemos a 0,
// el semáforo estará "rojo". Si lo ponemos a 1, estará "verde".
// El 0 de la función semctl es el índice del semáforo que queremos
// inicializar dentro del array de 10 que hemos pedido.

arg.val = 0;
semctl (Id_Semaforo, 0, SETVAL, &arg);


// Para "pasar" por el semáforo si está "rojo", debemos rellenar esta estructura.
// sem_num es el indice del semáforo en el array por el que queremos "pasar"
// sem_op es -1 para hacer que el proceso espere al semáforo.
// sem_flg son flags de operación. De momento nos vale un 0.

Operacion.sem_num = 0;
Operacion.sem_op = -1;
Operacion.sem_flg = 0;

// Bucle infinito indicando cuando entramos al semáforo y cuándo salimos
// de él.
// i hace de contador del número de veces que hemos salido del semáforo.
//
while (1)
{
printf("%i Esperando semaforo\n",i );

// Se hace la espera en el semáforo. Se le pasa un array de operaciones
// y el número de elementos en dicho array. En nuestro caso solo 1.

semop (Id_Semaforo, &Operacion, 1);
printf("%i Salgo de Semaforo\n ",i);
i++;
}
}



Y adjunto el segundo archivo con el otro semáforo,

Archivo 2
ej_sem2.c


#include
#include
#include
#include
#include
#include

// Esta union hay que definirla o no según el valor de los defines aqui indicados.

#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
// La union ya está definida en sys/sem.h
#else
// Tenemos que definir la union

union semun
{
int val;
struct semid_ds *buf;
unsigned short int *array;
struct seminfo *__buf;
};
#endif

int main(void)
{
key_t Clave;
int Id_Semaforo;
struct sembuf Operacion;
union semun arg;
int i;

// Igual que en cualquier recurso compartido (memoria compartida, semaforos
// o colas) se obtien una clave a partir de un fichero existente cualquiera
// y de un entero cualquiera. Todos los procesos que quieran compartir este
// semaforo, deben usar el mismo fichero y el mismo entero.

Clave = ftok ("/bin/ls", 33);
if (Clave == (key_t)-1)
{
printf("No puedo conseguir clave de semaforo\n");
exit(0);
}

// Se obtiene un array de semaforos (10 en este caso, aunque solo se usara uno.
// El IPC_CREAT indica que lo cree si no lo esta
// el 0600 con permisos de lectura y escritura para el usuario que lance
// los procesos. Es importante el 0 delante para que se interprete en
// octal.

Id_Semaforo = semget (Clave, 10, 0600 | IPC_CREAT);
if (Id_Semaforo == -1)
{
printf("No puedo crear semaforo\n");
exit (0);
}

// Se levanta el semáforo. Para ello se prepara una estructura en la que
// sem_num indica el indice del semaforo que queremos levantar en el array
// de semaforos obtenido.
// El 1 indica que se levanta el semaforo
// El sem_flg son banderas para operaciones raras. Con un 0 vale.
//
Operacion.sem_num = 0;
Operacion.sem_op = 1;
Operacion.sem_flg = 0;

// Vamos a levantar el semáforo 10 veces esperando 1 segundo cada vez.

for (i = 0; i<10;>

Para correr los archivos .c se compilan en consola con:
# gcc  ej_sem1.c -o ej_sem1

Y para correrlo:
# ./ej_sem1


Lo mismo con el segundo archivo, se corre cada uno en una consola diferente y veremos como funcionan los semáforos del sistema operativo linux/unix.

Para mayor referencia visiten este sitio:
http://www.chuidiang.com/clinux/ipcs/semaforo.php
viernes, 9 de enero de 2009 2 comentarios

Detectar Enter en QLineEdit de QT

Estoy usando un QLineEdit para ingresar texto, puse un botón de Ingreso para aceptar el texto del QLineEdit, quería hacer lo mismo pero al presionar enter, para esto solo se debe de usar el evento returnPressed() en un slot sobre el QLineEdit y cada vez que se presiona enter al estar el puntero sobre él accionará el evento.


2 comentarios

Jugadores Invisibles en FIFA 2009












Instalé FIFA 2009 y primero tenía problemas con la velocidad del juego, le cambié la resolución a la pantalla en las opciones de FIFA y se arregló.
Jugué varios partidos y en una de esas inicié un partido pero los jugadores no se miraban, estaban invisibles y solo se miraba la pelota y las sombras de los jugadores, para arreglar este problema hay que reinstalar los drivers de video.
Yo tengo una tarjeta ATI de 256mb, yo formatié windows desde los discos de rescate y me instala los drivers de una vez, entonces busque los drivers de mi tarjeta, los instalé y listo, ya se veían los jugadores.
jueves, 8 de enero de 2009 0 comentarios

Blog oficial de COECYS

Ya contamos con página oficial para coecys 2009 (congreso de estudiantes de Ciencias y Sistemas), el diseño está bastante bonito:


La dirección del blog es:

www.coecys.com/blog
 
;