int main()
{
int num[2];
std::string ip;
std::stringstream sstm;
int *res = NULL;
SocketDatagrama socket;
num[0] = 2;
num[1] = 5;
PaqueteDatagrama paq1(sizeof(int));
socket.setTiempoEspera(0.5);
for (int i = 1; i<=20; i++) {
//sstm << "192.168.0." << i;
sstm << "10.16.0." << i;
ip = sstm.str();
std::cout << "ip:" << ip << std::endl;
sstm.str("");
PaqueteDatagrama paq((char *)num,2 * sizeof(int),(char *)ip.c_str(),7200);
socket.envia(paq);
if(socket.recibe(paq1) != -1)
{
res = (int *)paq1.obtieneDatos();
std::cout << "RESPUESTA: " << *res << "DESDE: "<< ip << std::endl;
}
else
{
std::cout << "PERDIDO DESDE: " << ip << std::endl;
}
}
return 0;
}
int
main (int argc, char *argv[])
{
bool control = false;
if(argc>1)
{
control = true;
}
std::cout << control;
pthread_t th1, th2, th3, th4, th5;
pthread_create(&th1, NULL, &servicioSuma, NULL);
pthread_create(&th2, NULL, &comunicacion, NULL);
sleep(2);
if(control)
{
SocketDatagrama socket;
socket.activaBroadcast();
sem_init(&mutex1, 0, 1);
sem_init(&mutex2, 0, 0);
pthread_create(&th3, NULL, &broadcast, &socket);
pthread_create(&th4, NULL, &ordenamientoImpresion, NULL);
pthread_create(&th5, NULL, &recepcion, &socket);
pthread_join(th3, NULL);
pthread_join(th4, NULL);
pthread_join(th5, NULL);
}
pthread_join(th1, NULL);
pthread_join(th2, NULL);
exit(0);
}
// Será mejor cambiar implementación a una con hilos
// En la que un hilo escuche y otro hilo envíe los datos al servidor de la base
// 1) Recibir mensaje en escucha() indefinidamente
// 2) Enviar mensajes en enviar() mientras un contador no llegue al limite del std::vector
int main(int argv , char** argc){
int i = 0;
if(argv < 2) {
printf("Ejecutar con: %s IPservidorBD puertoServidorBD \n",argc[0]);
exit(1);
} else{
IPServerBD = new char[ strlen(argc[1]) ];
memcpy( IPServerBD, argc[1] , strlen(argc[1]) );
PORT = atoi(argc[2]);
//socketV = new SocketDatagrama( atoi(argc[3]) );
}
cout<<"********************************"<<endl;
cout<<"INICIANDO SERVIDOR DE VOTACIONES"<<endl;
cout<<"IP Local: "<<socketV.getDireccionLocal()<<endl;
cout<<"Servidor de BD: "<< IPServerBD << ":" << PORT <<endl;
cout<<"********************************"<<endl;
socketV.setTiempoDeBloqueo(2,1); // segundo, milisegundo
thread escucha (recibirVoto); //ejecuta hilo escucha
thread envia (enviarVotosAServer); //ejecuta hilo recibe
escucha.join(); // para evitar que la ejecucion de main() termine y, con ello, el programa
}
void *recepcion(void * aux)
{
SocketDatagrama * sok = (SocketDatagrama *)aux;
PaqueteDatagrama paq1(sizeof(int));
while(1) {
sok->recibe(paq1);
vectorIps.push_back (std::string(paq1.obtieneDireccion()));
}
pthread_exit(0);
}
void *broadcast(void * aux)
{
SocketDatagrama * sok = (SocketDatagrama *)aux;
int num[2] = {2,5};
PaqueteDatagrama paq((char *)num,2 * sizeof(int),ipBroadcast,puertoBroadcast);
while(1) {
sem_wait(&mutex1);
std::cout << "enviando..." << std::endl;
sok->envia(paq);
sleep(10);
sem_post(&mutex2);
}
pthread_exit(0);
}
int main()
{
SocketDatagrama server = SocketDatagrama(7200);
server.setBroadcast(true);
PaqueteDatagrama in = PaqueteDatagrama(0);
printf("xD\n");
while(1)
{
server.recibe(&in);
printf("Recibe de %s:%d\n", in.obtieneDireccion(), in.obtienePuerto());
PaqueteDatagrama out = PaqueteDatagrama(NULL,0,in.obtieneDireccion(), in.obtienePuerto());
server.envia(&out);
}
}
void *recibe(void*)
{
PaqueteDatagrama pr(sizeof(int));
char ip[16];
while(1)
{
//int c=0;
printf("\n fee\n");
if(s.recibe(pr))
{
printf("recibido: ");
printf("\n %s \n",pr.obtieneDireccion());
memcpy(ip,(char *)pr.obtieneDireccion(),16);
printf("\n %s \n",ip);
lista.push_back(ip);
contador.push_back( c);
c++;
//printf("\n %s \n",lista[c]);
}
}
}
int main(void)
{
pthread_t th1, th2, th3;
s.concurrente();
// Inicializa los semaforos
sem_init(&mutex1, 0, 1);
sem_init(&mutex2, 0, 0);
/* Se crean dos hilos con atributos predeterminados */
pthread_create(&th1, NULL, &broadcast, NULL);
pthread_create(&th2, NULL, &ordena, NULL);
pthread_create(&th3, NULL, &recibe, NULL);
//printf("El hilo principal espera a sus hijos\n");
//}
/* se espera su terminación */
pthread_join(th1, NULL);
pthread_join(th2, NULL);
pthread_join(th3, NULL);
printf("El hilo principal termina\n");
exit(0);
}
int main()
{
SocketDatagrama socket = SocketDatagrama(7300);
int * numeros;
PaqueteDatagrama datagrama = PaqueteDatagrama( 2 * sizeof(int));
socket.recibe(&datagrama);
numeros = (int *) datagrama.obtieneDatos();
int * ans = (int *)malloc(sizeof(int));
*ans = numeros[0] + numeros[1];
cout << "Numeros recibidos " << numeros[0] << " y " << numeros[1]
<< " de " << datagrama.obtieneDireccion() << ":" << datagrama.obtienePuerto() << endl;
PaqueteDatagrama databack = PaqueteDatagrama((char*) ans, sizeof(int), datagrama.obtieneDireccion(), datagrama.obtienePuerto());
socket.envia(&databack);
return 0;
}
int main()
{
int num[2];
char ip[] = "192.168.0.116";
int *res;
SocketDatagrama socket;
num[0] = 2;
num[1] = 5;
PaqueteDatagrama paq((char *)num,2 * sizeof(int),ip,7200);
socket.envia(paq);
PaqueteDatagrama paq1(sizeof(int));
socket.recibe(paq1);
res = (int *)paq1.obtieneDatos();
std::cout << "RESPUESTA: " << *res << std::endl;
return 0;
}
int main(void){
pthread_t th1, th2, th3;
SocketDatagrama socket;
socket.activaBroadcast();
// Inicializa los semaforos
sem_init(&mutex1, 0, 1);
sem_init(&mutex2, 0, 0);
// Crea hilos
pthread_create(&th1, NULL, &broadcast, &socket);
pthread_create(&th2, NULL, &ordenamientoImpresion, NULL);
pthread_create(&th3, NULL, &recepcion, &socket);
// Esperar a que los hilos terminen
pthread_join(th1, NULL);
pthread_join(th2, NULL);
pthread_join(th3, NULL);
exit(0);
}
void enviarVotosAServer(void){
// Enviar desde vector mientras no se llegue al limite del mismo
while(1){
while(mensajesPendientes>0){
//cout<<"Enviando voto a base..."<<endl;
PaqueteDatagrama mensajeVoto((char*)(&votos[ultimoMensajeEnviado]),sizeof(struct Mensaje),IPServerBD,PORT);
socketV.envia(mensajeVoto);
ultimoMensajeEnviado ++;
--mensajesPendientes;
cout<<"Mensaje enviado. Pendientes: "<<mensajesPendientes<<endl;
usleep(300000);
}
cout<<"Votos en cola de espera: "<<mensajesPendientes<<endl;
sleep(10); // Envia datos a la base casa 10 segundos
}
}
void *broadcast(void*)
{
PaqueteDatagrama p((char *)num, sizeof(int)*2,"192.168.0.255", 7200);
while(1)
{
sem_wait(&mutex1);
printf("\n broadcast->Recibiendo... \n");
s.envia(p);
sleep(5);
sem_post(&mutex2);
//pthread_exit(0);
}
}
//----------------------------------------------------
// Recibir, en packRecv, cada mensaje desde clienteSMS
//----------------------------------------------------
void recibirVoto(void){
int i=0;
cout<<"Iniciando escucha..."<<endl;
while(1){
struct Mensaje* voto;
char* sentencia;
if(socketV.recibe(packRecv) != -1){
voto = (struct Mensaje*) packRecv.obtieneDatos();
//cout << "--------------------------"<<endl;
cout << i+1<<"°] Voto recibido" <<endl;
/*cout << "--------------------------"<<endl;
cout << "Celular: "<< voto->celular <<endl;
cout << "CURP: "<< voto->CURP <<endl;
cout << "Partido: "<< voto->partido <<endl;
cout << "Nombre: "<< voto->nombre <<endl;
cout << "--------------------------"<<endl<<endl;*/
i++;
nuevoVoto(voto);
/*
*Parte que guarda en el log la estructura
*/
char* votoChar;
char vo[150] ="";
strcat (vo,voto->celular);
strcat (vo,"|");
strcat (vo,voto->CURP);
strcat (vo,"|");
strcat (vo,voto->partido);
strcat (vo,"|");
strcat (vo,voto->nombre);
votoChar = vo;
write_journal_entry(votoChar);
}//else{ cout<<"S_TO"<<endl;}
}
}
int main(int argc, char **argv)
{
struct birdPackage infoToSend, infoReceived;
int port;
char serverIp [16];
if (argc != 3) {
std::cout << "USO flappy <serverIp> <port>" << std::endl;
exit(-1);
}
strcpy(serverIp, argv[1]);
port = atoi(argv[2]);
SocketDatagrama socket;
std::cout << "Enviando al servidor: " << serverIp << " : " << port << " datos iniciados" << std::endl;
bzero(&infoToSend,sizeof(birdPackage));
bzero(&infoReceived,sizeof(birdPackage));
/* CONEXION POR PRIMERA VEZ */
infoToSend.opcode = NEW;
std::cout << "OPCODE: " << infoToSend.opcode << std::endl;
PaqueteDatagrama paq((char *)&infoToSend, sizeof(birdPackage), serverIp, port);
socket.envia(paq);
PaqueteDatagrama receive(sizeof(birdPackage));
socket.recibe(receive);
memcpy(&infoReceived, receive.obtieneDatos(), sizeof(birdPackage));
if(infoReceived.opcode == DENY) //Se rechaza al jugador, por lo que se tiene que salir
{
std::cout << "Partida llena intente más tarde..." << std::endl;
exit(-1);
}else{
nJugador = infoReceived.jugadorNum;
infoToSend.opcode = JUMP;
std::cout << "Partida iniciada, jugador: " << nJugador << std::endl;
}
SDL_Init(SDL_INIT_VIDEO);
SDL_Window *ventana = SDL_CreateWindow("Hi", 200, 200, 864, 510, SDL_WINDOW_SHOWN);
SDL_Renderer *render = SDL_CreateRenderer(ventana, -1, SDL_RENDERER_ACCELERATED);
//se carga la imagen que contiene todos los graficos
SDL_Surface * bmp = SDL_LoadBMP("atlas.bmp");
//se define el blanco como color transparente
SDL_SetColorKey(bmp, 1, SDL_MapRGB(bmp->format, 255, 255, 255));
SDL_Texture *textura = SDL_CreateTextureFromSurface(render, bmp);
SDL_FreeSurface(bmp);
SDL_Event event;
if (textura == NULL) {
std::cout << "FAILED TO FIND THE IMAGE" << std::endl;
}
SDL_RenderClear(render);
renderFondo(render, textura);
//Inicializa la posición de los pajaros dentro de la pantalla, pasandolos del atlas.bmp al recuadro del juego
initPajarosOrigen(render, textura);
SDL_RenderPresent(render);
int done = 1;
double angulo = 330;
const int FPS = 24;
//Cuantos frames por segundo queremos, 60 es el que utilizan los televisores
const int DELAY_TIME = 1000.0f / FPS;
//1000 ms entre los fps da el numero de milisegundos entre cada frame
Uint32 frameStart, frameTime;
while (done) {
frameStart = SDL_GetTicks();
//validacion del piso
if (rectangulo_destino[nJugador].y < 500) {
rectangulo_destino[nJugador].y += 10;
}
//validacion del angulo maximo
if (angulo < 450) {
angulo += 15;
}
//mientras exista un evento en el pila de eventos
while (SDL_PollEvent(&event)) {
//salto
if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_SPACE) {
rectangulo_destino[nJugador].y -= 100;
angulo = 300;
infoToSend.opcode = 1;
} else if (event.type == SDL_QUIT) {
infoToSend.opcode = CLOSE;
done = 0;
}
}
//enviar Paquete con las coordenadas
infoToSend.jugadorNum = nJugador;
infoToSend.posicionJUMP_X[nJugador] = rectangulo_destino[nJugador].x;
infoToSend.posicionJUMP_Y[nJugador] = rectangulo_destino[nJugador].y;
infoToSend.angulo[nJugador] = angulo;
PaqueteDatagrama paq((char *)&infoToSend, sizeof(birdPackage), serverIp, port);
socket.envia(paq);
//Recibir paquete con las coordenadas actualizadas
PaqueteDatagrama receive(sizeof(birdPackage));
socket.recibe(receive);
memcpy(&infoReceived, receive.obtieneDatos(), sizeof(birdPackage));
//se pinta actualiza el render
SDL_RenderClear(render);
renderFondo(render, textura);
int i = 0;
//Actualiza la posicion de los pajaros
for (int i = 0; i < 3; ++i)
{
rectangulo_destino[i].x = infoReceived.posicionJUMP_X[i];
rectangulo_destino[i].y = infoReceived.posicionJUMP_Y[i];
angulos[i] = infoReceived.angulo[i];
}
for (i = 0; i < infoReceived.jugadoresTotales; ++i)
{
//funciona como copy pero rota la imagen con el angulo
SDL_RenderCopyEx(render, textura, &rectangulo_origen[i], &rectangulo_destino[i], infoReceived.angulo[i], NULL, SDL_FLIP_NONE);
}
SDL_RenderPresent(render);
frameTime = SDL_GetTicks() - frameStart;
//Tiempo que ha tardado en presentarse el frame
if (frameTime < DELAY_TIME)//Si es menor al tiempo que deber à a ser
{
SDL_Delay((int)(DELAY_TIME - frameTime));//Espera un tiempo
}
}
/* Free all objects */
SDL_DestroyTexture(textura);
SDL_DestroyRenderer(render);
SDL_DestroyWindow(ventana);
/* Quit program */
SDL_Quit();
return 0;
}
