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; }