void task(int x_origen, int y_origen) {
/* Tarea */
//breakpoint();
//while(1);
int x_actual = x_origen;
int y_actual = y_origen;
//breakpoint();
while (TRUE)
{
int direccion = syscall_olfatear();
if (direccion == AQUI)
break;
actualizar(&x_actual, &y_actual, direccion);
syscall_moverse(direccion);
}
while (syscall_cavar() != 0)
{}
ir_hacia_desde(0, y_actual, &x_actual, &y_actual);
ir_hacia_desde(0, 0, &x_actual, &y_actual);
ir_hacia_desde(x_origen, 0, &x_actual, &y_actual);
ir_hacia_desde(x_origen, y_origen, &x_actual, &y_actual);
while(1) { __asm __volatile("mov $2, %%eax":::"eax"); }
}
void Tamagotchi::valores(QString name)
{
ui->BarraVida->setValue(create_window.granja->getPos(buscar(name))->vida);
ui->BarraHigiene->setValue(create_window.granja->getPos(buscar(name))->desechos);
ui->BarraSalud->setValue(create_window.granja->getPos(buscar(name))->enfermedad);
ui->BarraDormir->setValue(create_window.granja->getPos(buscar(name))->sueno);
ui->BarraComida->setValue(create_window.granja->getPos(buscar(name))->hambre);
actualizar();
}
void ir_hacia_desde(char x_dest, char y_dest, int * x_actual, int * y_actual)
{
char dir_h = x_dest > *x_actual ? DER : IZQ;
char dir_v = y_dest > *y_actual ? ABA : ARR;
int dist_x = x_dest > *x_actual ? x_dest - *x_actual : *x_actual - x_dest;
int dist_y = y_dest > *y_actual ? y_dest - *y_actual : *y_actual - y_dest;
int i = 0;
for (i = dist_x; i>0; i--) {
actualizar(x_actual, y_actual, (int)dir_h);
syscall_moverse(dir_h);
}
for (i = dist_y; i>0; i--) {
actualizar(x_actual, y_actual, (int)dir_v);
syscall_moverse(dir_v);
}
}
void GL_Contexto::correr()
{
if(iniciar())
{
cargar();
DeltaTiempo=0;
while(!glfwWindowShouldClose(_ventana))
{
_frame_pasado = glfwGetTime();
glfwPollEvents();
actualizar();
renderizar();
DeltaTiempo=glfwGetTime()-_frame_pasado;
}
terminar();
glfwTerminate();
}
}
// Hilo encargado de la ejecución de los procesos
void ejecutarProceso(proceso *procesoActual){
int shmid, datosID,llaveSegmento, contadorLinea, tipo;
char *prefijo = (char*)malloc(TAMANIO_LINEAS);
char *prefijoLog = (char*)malloc(TAMANIO_LINEAS);
char *shm;
datos *segmentoDatos;
sem_t *mutex,*semDatos;
int tamanioMem;
char *tipoProceso = (char*)malloc(30);
tipo = procesoActual->tipo;
switch(procesoActual->tipo){
case TIPO_WRITER:
sprintf(tipoProceso,"%s", WRITER);
sprintf(prefijo,"1|%s|%3d",WRITER,procesoActual->id);
sprintf(prefijoLog,"%s|%3d",WRITER,procesoActual->id);
llaveSegmento = LLAVE_SEGMENTO_WRITERS;
break;
case TIPO_READER:
sprintf(tipoProceso, "%s", READER);
sprintf(prefijoLog,"%s|%3d",READER,procesoActual->id);
llaveSegmento = LLAVE_SEGMENTO_READERS;
break;
case TIPO_READER_EGOISTA:
sprintf(tipoProceso, "%s", READER_EGOISTA);
sprintf(prefijoLog,"%s|%3d",READER_EGOISTA,procesoActual->id);
llaveSegmento = LLAVE_SEGMENTO_READERS_EGOISTAS;
break;
default:
break;
}
if(shmid = getMemID(LLAVE_SEGMENTO,NULL)){
datosID = getMem(LLAVE_SEGMENTO_DATOS);
shm = getMem(shmid);
segmentoDatos = getMem(datosID);
tamanioMem = getCantidadLineas() * TAMANIO_LINEAS;
mutex = sem_open(SEM_NAME,0,0644,1);
semDatos = sem_open(SEM_DATOS_NAME,0,0644,1);
}
else{
mutex = sem_open(SEM_NAME,O_CREAT,0644,1);
semDatos = sem_open(SEM_DATOS_NAME,O_CREAT,0644,1);
}
while(EXITO){
// Inicializamos el semaforo
if(tipo == TIPO_WRITER){
sem_wait(mutex);
sem_wait(semDatos);
/////////////////////////////////////////////////////
//region critica
if(getMemID(LLAVE_SEGMENTO,NULL)){
if(getLectores() == 0){
// Tiempo de escritura
if(contadorLinea = escribir(prefijo,tamanioMem,shm,procesoActual)){
setLectura(0);decReader();
actualizar(llaveSegmento,prefijoLog,procesoActual);
registrar(procesoActual);
sleep(procesoActual->escritura);
setLectura(1);
}
}
}
else{
sem_post(semDatos);
sem_post(mutex);
break;
}
sem_post(semDatos);
sem_post(mutex);
}
else if(tipo == TIPO_READER){
sem_wait(semDatos);
if(getMemID(LLAVE_SEGMENTO,NULL)){
if(getLectura()){
decReader();
incLectores();
sem_post(semDatos);
leer(tamanioMem,shm,procesoActual);
sem_wait(semDatos);
decLectores();
}
}
else{
sem_post(semDatos);
break;
}
sem_post(semDatos);
}
else if(tipo == TIPO_READER_EGOISTA){
/////////////////////////////////////////////////////
//region critica
sem_wait(mutex);
sem_wait(semDatos);
if(getMemID(LLAVE_SEGMENTO,NULL)){
if(incReader()<4 && getLectores() == 0){
// Tiempo de escritura
if(contadorLinea = borrar(tamanioMem,shm,procesoActual)){
setLectura(0);
actualizar(llaveSegmento,prefijoLog,procesoActual);
registrar(procesoActual);
sleep(procesoActual->escritura);
setLectura(1);
}
}
}
else{
sem_post(semDatos);
sem_post(mutex);
break;
}
sem_post(semDatos);
sem_post(mutex);
}
// Tiempo de descanso
procesoActual->estado = ESTADO_DESCANSO;
actualizar(llaveSegmento,prefijoLog,procesoActual);
sleep(procesoActual->descanso);
/////////////////////////////////////////////////////
// Luego de dormir se bloquean y esperan el semáforo
procesoActual->estado = ESTADO_BLOQUEADO;
actualizar(llaveSegmento,prefijoLog,procesoActual);
}
// Al no encontrar memoria compartida
// el proceso muere.
//sem_post(mutex);
sem_close(mutex);
sem_close(semDatos);
printf("El %s %d fue finalizado.\n",tipoProceso,procesoActual->id);
}
int main(int argc, char *argv[]) {
system("clear");
int fd_socket_servidor, fd_comunicacion;
struct sockaddr_in dir_servidor;
struct sockaddr_in dir_cliente;
int sin_size;
int clienteNum = 0;
int contador;
if ((fd_socket_servidor = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
fprintf(stderr, "Error en socket\n");
exit(-1);
}
dir_servidor.sin_family = AF_INET;
dir_servidor.sin_addr.s_addr = INADDR_ANY;
dir_servidor.sin_port = htons(PORT);
bzero(&(dir_servidor.sin_zero), 8);
if (bind(fd_socket_servidor, (struct sockaddr*) &dir_servidor, sizeof(struct sockaddr)) == -1) {
fprintf(stderr, "Error en bind\n");
exit(-1);
}
if (listen(fd_socket_servidor, BACKLOG) == -1) {
fprintf(stderr, "Error en listen\n");
exit(-1);
}
contador = 0;
while (1) {
trama = (char *)malloc(sizeof(char) *250);
printf("Server esperando...\n");
sin_size = sizeof(dir_cliente);
if ((fd_comunicacion = accept(fd_socket_servidor, (struct sockaddr*) &dir_cliente, &sin_size)) == -1) {
fprintf(stderr, "Error en accept\n");
exit(-1);
}
// Empezamos el proceso del cliente que llega, para no tener un solo proceso para todos los clientes, creamos mas procesos.
if (fork() == 0) {
// 1. Server recibe es el numero de cuenta
if ((inf_tam_byte = recv(fd_comunicacion, recepNoCta, TAMANIO_MAX, 0)) == -1) {
fprintf(stderr, "Error en recibir\n");
exit(1);
}
//Verificamos que exista y devolvemos una cadena con los datos de la cuenta.
recepNoCta[inf_tam_byte] = '\0'; //Asignamos a la posicion final el fin de cadena '\0'
printf("Cta Recibida: %s\n", recepNoCta);
sleep(1);
//de aqui se manda a imprimir o algo
trama = verificarCtaBase(recepNoCta);
if (trama == NULL) {
printf("Dentro de trama=NULL: %s\n", contador);
//cuenta incorrecta, se aniade
//fprintf(stderr, "Cuenta incorrecta\n");
//printf("Se aniadira a la base de datos\n");
sprintf(trama, "%s + 10.00 %s",recepNoCta, recepNoCta);
printf("Trama transacc %s\n", trama);
guardarEnArchivo(ARCHIVO_TRANSACCIONES, trama);
sprintf(trama, "%s 10.00",recepNoCta); //la trama se queda al final lista para enviarla
guardarEnArchivo(ARCHIVO_CUENTAS, trama);
printf("Trama transacc%s\n", trama);
}
if (send(fd_comunicacion, trama, strlen(trama)+1, 0) == -1) {
perror("send");
fprintf(stderr, "No se pudo enviar trama\n");
//close(fd_comunicacion);
exit(0);
}
sleep(1);
if ((inf_tam_byte = recv(fd_comunicacion, recepTransaccion, TAMANIO_MAX, 0)) == -1) {
perror("recv");
exit(1);
}
recepTransaccion[inf_tam_byte] = '\0'; //Asignamos a la posicion final el fin de cadena '\0'
printf("Transaccion Recibida: %s\n", recepTransaccion);
sleep(1);
if(strcmp(actualizar(recepTransaccion), "correcto")==0){
printf("Datos actualizados");
}
guardarEnArchivo(ARCHIVO_TRANSACCIONES, recepTransaccion);
} else {
close(fd_comunicacion);
/* Se suspende la ejecucion del proceso padre hasta que finalice el proceso hijo */
while (waitpid(-1, NULL, WNOHANG) > 0);
}
//printf("Cliente %d: Desde %s \n", clienteNum, inet_ntoa(dir_cliente.sin_addr));
//send(fd_comunicacion, "Bienvenido a mi servidor!!!\n", 30, 0);
//close(fd_comunicacion);
clienteNum++;
}
printf("Error en listen\n");
exit(-1);
}
/**
* \brief Default constructor
*/
SpecificWorker::SpecificWorker(MapPrx& mprx) : GenericWorker(mprx)
{
connect(ci, SIGNAL(clicked()), this, SLOT(moverpataci()));
connect(cd, SIGNAL(clicked()), this, SLOT(moverpatacd()));
connect(Xpos, SIGNAL(clicked()), this, SLOT(xpos()));
connect(Xneg, SIGNAL(clicked()), this, SLOT(xneg()));
connect(Ypos, SIGNAL(clicked()), this, SLOT(ypos()));
connect(Yneg, SIGNAL(clicked()), this, SLOT(yneg()));
connect(Zpos, SIGNAL(clicked()), this, SLOT(zpos()));
connect(Zneg, SIGNAL(clicked()), this, SLOT(zneg()));
connect(Actualizar, SIGNAL(clicked()), this, SLOT(actualizar()));
inner = new InnerModel("/home/ivan/robocomp/files/innermodel/hexapod1pata.xml");
Posini=inner->transform("base","axisA1T");
Posfin=Posini;
QVec aux=inner->transform("arm1motor2","arm1motor3");
qDebug()<<aux;
angle1=atan(aux.y()/aux.z());
Femur=aux.norm2();
aux=inner->transform("arm1motor3","axisA1T");
angle2=atan(aux.y()/aux.z());
Tibia=aux.norm2();
qDebug()<<aux;
Coxa=52;
qDebug()<<"-----------------------------";
qDebug()<<" Coxa = "<<Coxa;
qDebug()<<" Femur = "<<Femur;
qDebug()<<" Tibia = "<<Tibia;
qDebug()<<" angle1 = "<<angle1;
qDebug()<<" angle2 = "<<angle2;
qDebug()<<"-----------------------------";
// Femur=sqrt(14.5*14.5+64.5*64.5);
// Tibia=sqrt(123.714*123.714+ 23.6179 *23.6179);
H=18.5;
// Posini=QVec::zeros(3);
// RoboCompJointMotor::MotorParamsList mp = jointmotor_proxy->getAllMotorParams();
// RoboCompJointMotor::MotorGoalPositionList mg;
// for(auto m:mp){
// cout<<m.name<<endl;
// RoboCompJointMotor::MotorGoalPosition p;
// p.name=m.name;
// p.maxSpeed=0.1;
// p.position=0;
// mg.push_back(p);
// // mg.insert(p);
// }
// jointmotor_proxy->setSyncPosition(mg);
m1="arm1motor1";
m2="arm1motor2";
m3="arm1motor3";
}
int main (){
int op,opc=0,opcls=0,clave=0,edades=0,i;
int numreg=0;
char expresion[20];
struct agenda reg;
printf("Creado por Vicente Mendoza");
apertura();
menu:
op = menu();
switch (op){
case 1:
agregar(); //*********
goto menu; //AGREGAR
break; //*********
case 2:
printf("Dame la clave a borrar: ");
scanf ("%d",&clave); //*********
borrar(clave); //BORRAR
printf("tRegistro Borrado: %d",clave); //*********
goto menu;
break;
case 3:
printf ("t Como prefiere hacer la busqueda ?");
printf ("\n");
printf ("tt1. Por Nombre, Apellido Paterno y Materno");
printf ("\n"); //***********
printf ("tt2. Por Edad"); //BUSQUEDA
printf("ntOpcion: "); //***********
scanf("%d",&opc);
if(opc==1){
printf ("Escribe el Nombre o Apellidos a buscar: ");
scanf ("%s",expresion);
buscarnom(expresion);
}else if(opc=2){
printf ("Escribe la edad para buscar ");
scanf ("%d",&edades);
buscaredad(edades);
}
goto menu;
break;
case 4:
m_todo(); //*************
goto menu; //MOSTRAR_TODO
break; //*************
case 5:
ordena();
goto menu;
break;
case 6:
printf("n 1)Nombret2)Ap. Paternot3)Ap. Maternot4)Edadt5)Calle");
printf("nOpcion: ");
scanf("%d",&opcls);
numreg=ReadAllToDisk(); //******************
OrdenaOnMemory(numreg,opcls); //LISTAR
for(i=0;i<numreg;i++) //******************
mostrar(r[i]);
goto menu;
break;
case 7:
printf("nQue registro va actualizar (clave): ");
scanf("%d",&clave); //***************
reg=ReadToDisk(clave); //ACTUALIZAR
mostrar(reg); //***************
printf("nQue dato desea actualizar");
printf("n 1)Nombret2)Ap. Paternot3)Ap. Maternot4)Edadt5)Callet6)Telefonot7)Celulart8)Email ");
printf("n Opcion: ");
scanf("%d",&opcls);
actualizar(reg,opcls);
printf("nRegistro Actualizado");
goto menu;
break;
case 8:
exportar(); //****************
goto menu; //EXPORTAR EN CSV
break; //****************
case 9:
printf("n Ha terminado el programa..n");
break;
}
fclose(fichero);
return 1;
}
int main(int argc, char *argv[]) {
printf("Carregar a HashTable...\n\n");
ler();
char in[15];
int running=1;
int stock,max,quantidade;
char nome[15];
int modo;
while (running) {
printf("\n");
printf(" 1. Inserir\n");
printf(" 2. Procurar\n");
printf(" 3. Actualizar\n");
printf(" 4. Apagar\n");
printf(" 5. Ordenar\n");
printf(" 6. Sair e Gravar\n");
printf(" 7. Sair sem Gravar\n");
gets(in);
switch(atoi(in)) {
case 1:
printf("Insira o Nome\n");
gets(in); strcpy(nome,in);
printf("Indique o Stock\n");
gets(in); stock = atoi(in);
ins = cria_semaforo(1234,1);
P(ins);
inserir(nome,stock);
V(ins);
break;
case 2:
printf("Nome que Deseja Procurar\n");
gets(in); strcpy(nome,in);
pro = cria_semaforo(2345,1);
P(pro);
procurar(nome);
V(pro);
break;
case 3:
printf("Deseja Realizar uma Encomenda(1) ou uma Venda(2)");
gets(in); modo= atoi(in);
printf("Insira o Nome\n");
gets(in); strcpy(nome,in);
printf("Indique a Quantidade\n");
gets(in); quantidade= atoi(in);
actu = cria_semaforo(3456,1);
P(actu);
actualizar(nome,quantidade,modo);
V(actu);
break;
case 4:
printf("Nome que Deseja Remover\n");
gets(in); strcpy(nome,in);
apagar = cria_semaforo(4567,1);
P(apagar);
remover(nome);
V(apagar);
break;
case 5:
printf("Indique o Máximo do Top\n");
gets(in); max = atoi(in);
ordenar = cria_semaforo(5678,1);
P(ordenar);
sort(max);
V(ordenar);
break;
case 6:
grav = cria_semaforo(6789,1);
P(grav);
printf("A guardar ... ");
gravar();
V(grav);
running=0;
break;
case 7:
printf("Deseja sair sem guardar ? [s/n]");
gets(in); strcpy(nome,in);
if(strcmp("s",nome) == 0){
running=0;
}else{
running=1;
}
break;
}
}
libertar();
return 0;
}
