Esempio n. 1
0
void main(void){
  /* code */
  tienda p01, p02, *p03;
  lee(&p01);
  //lee(&p02);
  //escribe(&p01);
  //escribe(&p02);
  p03 = (tienda*)malloc(sizeof(tienda));
  //lee(p03);
  //escribe(p03);
}
Esempio n. 2
0
void main()
{
	long val=1777777;

	long ii;
	ii=lee((void *) &val);

	double dd=377e-177;
	dd=lee_d((void *) &dd);
	ii=ii;
}
Esempio n. 3
0
int sockets()
{	
	char Usuario [30];	
	printf("Digite el usuario \n");          // Se le solicita al usuario el username del contacto con el que desea cominicarse
	scanf("%s",&Usuario);			
		
	lee(Usuario);                            // Se llama a la función leer para validar que el usuario existe y a su vez nos devuelva la ip
											 // y el puerto asociado
	
	int socket1, nuevoSocket, numPuerto, mensaje,pid;   // Se declaran las variables necesarias para el socket
	socklen_t clilen;
	char buffer[1024];                                  // Tamaño del mensaje
	
	numPuerto = atoi(puerto);                           // Se convierte el numero de puerto a entero
	
	pid = fork();                                       // Se guarda el id de proceso
	
	if (pid < 0){										// Error si el fork devuelve un -1 
		error("El fork no se realizo de forma correcta\n");
	}
	
	//Si el id es igual a 0 se cierra el socket y se abre una nueva comunicacion
	if (pid == 0)                                       // La parte del sockect que envía
	{
				
		struct sockaddr_in dir_servidor;                // Se declaran las estructuras donde se 
		struct hostent *servidor;                       // guarda la ip del servidor
		
		while (1){                                      // Se crea un while infinito
			
			sleep (1);
			//Se crea el socket
			socket1 = socket(AF_INET, SOCK_STREAM, 0);
			
			//Muestra error en caso de no poder crear el socket
			if (socket1 < 0) error("El socket no se ha podido crear\n");
			
			//Obtiene la direccion ip del servidor
			if (existe == 1) {     // Si el usuario se encontraba en el archivo se llama a copiar para que elimine el \0
				copiar (ip, IP);
				servidor = gethostbyname(IP);
				}
			else servidor = gethostbyname(ip);
			
			//Si el servidor es nulo ,muestra el error 
			if (servidor == NULL)
			{
				fprintf(stderr,"Error, no se encuentra con quien conectar \n");
				exit(0);
			}
			
			//Rellena con 0
			bzero((char *) &dir_servidor, sizeof(dir_servidor));
			
			dir_servidor.sin_family = AF_INET;                  //Protocolo TCP
			
			//Copia la direccion
			bcopy((char *)servidor->h_addr,(char*)&dir_servidor.sin_addr.s_addr,servidor->h_length);
			
			dir_servidor.sin_port = htons(numPuerto);           //Representa el numero de puerto
			
			//Verifica que pueda establecer la conexion
			if (connect(socket1,(struct sockaddr *)&dir_servidor,sizeof(dir_servidor)) < 0) 
				error("Error, en crear la conexión");
			
			printf("\033[34m \n Yo: ");  // Es el printf que va indicar que le corresponde escribir
			
			//Relleno con ceros
			bzero(buffer,1024);
			
			//Lee el mensaje desde la entrada estandar
			fgets(buffer,1023,stdin);
			
						
			//Solicita escribir un mensaje
			mensaje = write(socket1,buffer,strlen(buffer));
			//Si se produce un error al escribir el msj, se muestra el error
			if (mensaje < 0)
				error("Error, no se pudo escribir el mensaje");
			
			if (strcmp(buffer,"salir\n")==0){    // Si el usuario digita "salir" la conversación se da por finalizada
				printf ("\033[31m Conversacion finalizada\n");
				sleep(2);
				system("clear");  // Limpia la pantalla
				break;
			}
			
			//Relleno con ceros
			bzero(buffer,1024);
			//Lee el mensaje
			mensaje = read(socket1,buffer,1023);
			
			//Si se produce un error al leer el msj, se muestra el error
			if (mensaje < 0)
				error("Error, no se puede leer el mensaje");
				
			//printf("%s", buffer);
			
			close(socket1);
	
		}
		return 0;
	}
		
	else {  //Servidor
	
		//printf("Entre al servidor");
		
		struct sockaddr_in dir_servidor, dir_cliente;
		socket1 = socket(AF_INET, SOCK_STREAM, 0);
		
		//validacion en caso de no se pueda establecer el socket
		if (socket1 < 0)
			error("Error, no se puede crear el socket");

		//Establece los valores del bufer a 0
		bzero((char *) &dir_servidor, sizeof(dir_servidor));
		//numPuerto obtine el numero de puerto ingresado por el usuario
		
		dir_servidor.sin_family = AF_INET;                  //Protocolo TCP
		dir_servidor.sin_addr.s_addr = INADDR_ANY;          //Representa la direccion ip
		dir_servidor.sin_port = htons(numPuerto);           //Representa el puerto

		//Verifica la conexion
		if (bind(socket1, (struct sockaddr *) &dir_servidor,sizeof(dir_servidor)) < 0)
			error("Error, no se puede crear la conexión");
		
		while(1){
			
			listen(socket1,5);
	
			//Tamaño de bytes que ocupa la direccion cliente
			clilen = sizeof(dir_cliente);
			
			//Se cra una nueva comunicación
			nuevoSocket = accept(socket1,(struct sockaddr *) &dir_cliente, &clilen);
			if (nuevoSocket < 0)
			error("Error, no se puede aceptar la conexión");
						
			bzero(buffer,256);
			sleep (2);
			//Lee el mensaje
			mensaje = read(nuevoSocket,buffer,255);
			//Muestra el error en caso de que se produzca
			if (mensaje < 0)
				error("Error, al leer el mensaje enviado");
			
			if (strcmp(buffer,"salir\n")==0){
				printf ("\033[33m Conversacion finalizada\n");
				sleep(2);
				Menu();
				sleep(2);
			}
			
			else{
				//Muestra el mensaje recibido
				printf("\033[32m \n %s:  %s\n",Usuario, buffer); //Muestra el mensaje enviado
					}
				
				close(nuevoSocket);
				}	
	}
	return 0;
}
Esempio n. 4
0
int main(){

	lee(3, 6, 3, 0);
	return 0;
}
Esempio n. 5
0
/**************************************************************************************************
*   inicia o pserve para receber as imagens e plota na ui
**************************************************************************************************/
void MainWindow::start_pserve()
{
    contagem=0;
    pixeis_lidos=0;
    QProcess *myProcess = new QProcess;
    QStringList arguments_pserve;
    process_pserve = Current_Path+"/pserve";
    arguments_pserve<<Count_L<<NImage<<Save_Path;
    myProcess->setProcessChannelMode(QProcess::MergedChannels);
    myProcess->start(process_pserve,arguments_pserve);
    myProcess->waitForStarted();
    QPixmap pixmap;
    float contagem_anterior;
    /**************************************************************************************************
    *   le uma imagem
    **************************************************************************************************/
    if(NImage.toInt()==1)
    {
        if(Count_L.toInt()==0) // 1 bit
        {
            contagem=0;
            pixeis_lidos=0;
            myProcess->waitForFinished((Time.toFloat()*1000)+100);
            QImage image(256,256,QImage::Format_Indexed8);
            if(image.load(Save_Path+"1.ppm","pbm")==true)
            {
                image.invertPixels();
                for(int a=0;a<=255;a++)
                {
                    for(int b=0;b<=255;b++)
                    {
                        contagem=contagem+(1-image.pixelIndex(b,a));
                        pixeis_lidos=contagem;
                    }
                }
            }
            else
            {
                image.fill(Qt::black);
                ui->textBrowser->append("Error Reading Image!!!");
            }
            pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
        }
        else if(Count_L.toInt()==1) // 12 bits
        {
            contagem=0;
            pixeis_lidos=0;
            myProcess->waitForFinished((Time.toFloat()*1000)+1000);
            QImage image(256,256,QImage::Format_RGB16);
            QByteArray teste;
            QFile filestr(Save_Path+"1.ppm");
            if(filestr.open(QIODevice::ReadOnly)==true)
            {
                teste=filestr.readAll();
                QString colorstr(teste);
                QStringList colors = colorstr.split(QRegExp("\\s+"));
                colors.removeLast();
                colors.removeFirst();
                colors.removeFirst();
                colors.removeFirst();
                colors.removeFirst();
                QVector<QRgb> colortable;
                Lookup_Tables ctable;
                colortable=ctable.colorPalete1280();
                image.setColorTable(colortable);
                int cont=0;
                for(int a=0;a<=255;a++)
                {
                    for(int b=0;b<=255;b++)
                    {
                        if(qCeil(colors.at(cont).toInt()/3.2)>=1280)
                        {
                            image.setPixel(b,a, image.colorTable().at(1279));
                        }
                        else
                        {
                            image.setPixel(b,a, image.colorTable().at(qCeil(colors.at(cont).toUInt()/3.2)));
                        }
                        contagem_anterior=contagem;
                        contagem=contagem+colors.at(cont).toFloat();
                        cont++;
                        if(contagem_anterior!=contagem)
                        {
                            pixeis_lidos++;
                        }
                    }
                }
            }
            else
            {
                image.fill(Qt::black);
                ui->textBrowser->append("Error Reading Image!!!");
            }
            pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
        }
        else if(Count_L.toInt()==2) // 6 bits
        {
            contagem=0;
            pixeis_lidos=0;
            myProcess->waitForFinished((Time.toFloat()*1000)+500);
            QImage image(256,256,QImage::Format_Indexed8);
            if(image.load(Save_Path+"1.ppm","pbm")==true)
            {
                QVector<QRgb> colortable;
                Lookup_Tables ctable;
                colortable=ctable.colorPalete64();
                image.setColorTable(colortable);
            }
            else
            {
                image.fill(Qt::black);
                ui->textBrowser->append("Error Reading Image!!!");
            }
            pixmap = QPixmap::fromImage(image,Qt::ColorOnly);

            for(int a=0;a<=255;a++)
            {
                for(int b=0;b<=255;b++)
                {
                    contagem_anterior=contagem;
                    contagem=contagem+image.pixelIndex(b,a);
                    if(contagem_anterior!=contagem)
                    {
                        pixeis_lidos++;
                    }
                }
            }
        }
        else if(Count_L.toInt()==3) // 24 bits
        {
            contagem=0;
            pixeis_lidos=0;
            myProcess->waitForFinished((Time.toFloat()*1000)+1500);
            QImage image(256,256,QImage::Format_RGB32);
            QByteArray teste;
            QFile filestr(Save_Path+"1.ppm");
            if(filestr.open(QIODevice::ReadOnly)==true)
            {
                teste=filestr.readAll();
                QString colorstr(teste);
                QStringList colors = colorstr.split(QRegExp("\\s+"));
                colors.removeLast();
                colors.removeFirst();
                colors.removeFirst();
                colors.removeFirst();
                colors.removeFirst();
                QVector<QRgb> colortable;
                Lookup_Tables ctable;
                colortable=ctable.colorPalete1280();
                image.setColorTable(colortable);
                int cont=0;
                for(int a=0;a<=255;a++)
                {
                    for(int b=0;b<=255;b++)
                    {
                        if(qCeil(colors.at(cont).toInt()/100)>=1536)
                        {
                            image.setPixel(b,a, image.colorTable().at(1535));
                        }
                        else
                        {
                            image.setPixel(b,a, image.colorTable().at(qCeil(colors.at(cont).toUInt()/100)));
                        }
                        contagem_anterior=contagem;
                        contagem=contagem+colors.at(cont).toFloat();
                        cont++;
                        if(contagem_anterior!=contagem)
                        {
                            pixeis_lidos++;
                        }
                    }
                }
            }
            else
            {
                image.fill(Qt::black);
                ui->textBrowser->append("Error Reading Image!!!");
            }
            pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
        }
        pixmap=pixmap.scaled(512,512);
        scene= new QGraphicsScene(this);
        scene->addPixmap(pixmap);
        ui->Plot_Window->setScene(scene);
        QByteArray text_response=myProcess->readAll();
        QString mystr(text_response);
        ui->textBrowser->setText(mystr);
        ui->textBrowser->append("Total Count = "+QString::number(contagem));
        ui->textBrowser->append("Pixel Read = "+QString::number(pixeis_lidos));
    }
    /**************************************************************************************************
    *   le +1 imagem
    **************************************************************************************************/
    else
    {
        Save_Dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
        Save_Dir.setSorting(QDir::Time);
        QString lee(Image_Name);
        int cont =0;
        lee.append(QString::number(cont));
        for(int a=0;a<=(NImage.toInt()-1);a++)
        {
            if(Count_L.toInt()==0) // 1 bit
            {
                if(a==(NImage.toInt()-1))
                {
                    myProcess->waitForFinished(NImage.toInt()*((Gap.toInt()*1000)+(Time.toFloat()*1000)+300));
                }
                else if(a==0)
                {
                    QThread::msleep((Time.toFloat()*1000)+300);
                }
                else
                {
                    QThread::msleep((Gap.toInt()*1000)+(Time.toFloat()*1000)+300);
                }
                cont++;
                lee.replace(lee.size()-1,1,QString::number(cont));
                QImage image(256,256,QImage::Format_Indexed8);
                image.load(Save_Dir.absolutePath()+"/"+lee+".ppm","pbm");
                image.invertPixels();
                pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
                pixmap=pixmap.scaled(512,512);
                scene= new QGraphicsScene(this);
                scene->addPixmap(pixmap);
                scene->update();
                ui->Plot_Window->setScene(scene);
                ui->Plot_Window->update();
                QByteArray text_response=myProcess->readAll();
                QString mystr(text_response);
                ui->textBrowser->setText(mystr);
                ui->textBrowser->update();
                QCoreApplication::processEvents(QEventLoop::AllEvents);
            }
            else if(Count_L.toInt()==1) // 12 bits
            {
                if(a==(NImage.toInt()-1))
                {
                    myProcess->waitForFinished(NImage.toInt()*((Gap.toInt()*1000)+(Time.toFloat()*1000)+1000));
                }
                else if(a==0)
                {
                    QThread::msleep((Time.toFloat()*1000)+1000);
                }
                else
                {
                    QThread::msleep((Gap.toInt()*1000)+(Time.toFloat()*1000)+1000);
                }
                QByteArray text_response=myProcess->readAll();
                QString mystr(text_response);
                ui->textBrowser->setText(mystr);
                cont++;
                lee.replace(lee.size()-1,1,QString::number(cont));
                QImage image(256,256,QImage::Format_RGB16);
                QByteArray teste;
                QFile filestr(Save_Dir.absolutePath()+"/"+lee+".ppm");
                filestr.open(QIODevice::ReadOnly);
                teste=filestr.readAll();
                QString colorstr(teste);
                QStringList colors = colorstr.split(QRegExp("\\s+"));
                colors.removeLast();
                colors.removeFirst();
                colors.removeFirst();
                colors.removeFirst();
                colors.removeFirst();
                QVector<QRgb> colortable;
                Lookup_Tables ctable;
                colortable=ctable.colorPalete1280();
                image.setColorTable(colortable);
                int cont=0;
                for(int a=0;a<=255;a++)
                {
                    for(int b=0;b<=255;b++)
                    {
                        if(qCeil(colors.at(cont).toInt()/3.2)>=1280)
                        {
                            image.setPixel(b,a, image.colorTable().at(1279));
                        }
                        else
                        {
                            image.setPixel(b,a, image.colorTable().at(qCeil(colors.at(cont).toUInt()/3.2)));
                        }
                        cont++;
                    }
                }
                pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
                pixmap=pixmap.scaled(512,512);
                scene= new QGraphicsScene(this);
                scene->addPixmap(pixmap);
                scene->update();
                ui->Plot_Window->setScene(scene);
                ui->Plot_Window->update();
                QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
            }
            else if(Count_L.toInt()==2) // 6 bits
            {
                if(a==(NImage.toInt()-1))
                {
                    myProcess->waitForFinished(NImage.toInt()*((Gap.toInt()*1000)+(Time.toFloat()*1000)+500));
                }
                else if(a==0)
                {
                    QThread::msleep((Time.toFloat()*1000)+500);
                }
                else
                {
                    QThread::msleep((Gap.toInt()*1000)+(Time.toFloat()*1000)+500);
                }
                QByteArray text_response=myProcess->readAll();
                QString mystr(text_response);
                ui->textBrowser->setText(mystr);
                cont++;
                //QFileInfoList list = Save_Dir.entryInfoList();
                //QFileInfo fileinfo = list.at(0);
                //image1 = fileinfo.fileName();
                lee.replace(lee.size()-1,1,QString::number(cont));
                //qDebug()<<Save_Dir.absolutePath()+"/"+lee+".ppm";
                QImage image(256,256,QImage::Format_Indexed8);
                image.load(Save_Dir.absolutePath()+"/"+lee+".ppm","pgm");
                QVector<QRgb> colortable;
                Lookup_Tables ctable;
                colortable=ctable.colorPalete64();
                image.setColorTable(colortable);
                pixmap=pixmap.scaled(512,512);
                pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
                scene= new QGraphicsScene(this);
                scene->addPixmap(pixmap);
                scene->update();
                ui->Plot_Window->setScene(scene);
                ui->Plot_Window->update();
                QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
            }
            else if(Count_L.toInt()==3) // 24 bits
            {
                if(a==(NImage.toInt()-1))
                {
                    myProcess->waitForFinished(NImage.toInt()*((Gap.toInt()*1000)+(Time.toFloat()*1000)+1500));
                }
                else if(a==0)
                {
                    QThread::msleep((Time.toFloat()*1000)+1500);
                }
                else
                {
                    QThread::msleep((NImage.toInt()*1000)+(Time.toFloat()*1000)+1500);
                }
                QByteArray text_response=myProcess->readAll();
                QString mystr(text_response);
                ui->textBrowser->setText(mystr);
                cont++;
                lee.replace(lee.size()-1,1,QString::number(cont));
                QImage image(256,256,QImage::Format_RGB32);
                QByteArray teste;
                QFile filestr(Save_Dir.absolutePath()+"/"+lee+".ppm");
                filestr.open(QIODevice::ReadOnly);
                teste=filestr.readAll();
                QString colorstr(teste);
                QStringList colors = colorstr.split(QRegExp("\\s+"));
                colors.removeLast();
                colors.removeFirst();
                colors.removeFirst();
                colors.removeFirst();
                colors.removeFirst();
                QVector<QRgb> colortable;
                Lookup_Tables ctable;
                colortable=ctable.colorPalete1280();
                image.setColorTable(colortable);
                int cont=0;
                for(int a=0;a<=255;a++)
                {
                    for(int b=0;b<=255;b++)
                    {
                        if(qCeil(colors.at(cont).toInt()/100)>=1536)
                        {
                            image.setPixel(b,a, image.colorTable().at(1535));
                        }
                        else
                        {
                            image.setPixel(b,a, image.colorTable().at(qCeil(colors.at(cont).toUInt()/100)));
                        }
                        cont++;
                    }
                }
                pixmap = QPixmap::fromImage(image,Qt::ColorOnly);
                pixmap=pixmap.scaled(512,512);
                scene= new QGraphicsScene(this);
                scene->addPixmap(pixmap);
                scene->update();
                ui->Plot_Window->setScene(scene);
                ui->Plot_Window->update();
                QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
            }
        }
    }
}
Esempio n. 6
0
int main() {
	connect_to_robot();
	initialize_robot();
	set_origin();

	printf("Ghandy-Bot activated, destroy!!!\n");

	//Set front IR sensors to to face left and right
	set_ir_angle(LEFT, -45);
    set_ir_angle(RIGHT, 45);

	init_map();
    print_map();

	robot.map[1][1].walls[0] = 1;
    robot.map[1][2].walls[2] = 1;

    robot.map[1][1].walls[1] = 1;
    robot.map[2][1].walls[3] = 1;

    robot.map[1][3].walls[2] = 1;
    robot.map[1][2].walls[0] = 1;

    robot.map[0][4].walls[2] = 1;
    robot.map[0][3].walls[0] = 1;

    robot.map[3][4].walls[3] = 1;
    robot.map[2][4].walls[1] = 1;

    robot.map[3][2].walls[2] = 1;
    robot.map[3][1].walls[0] = 1;

    robot.map[3][2].walls[3] = 1;
    robot.map[2][2].walls[1] = 1;
    int i;
    for(i=1;i<=4;i++)
        robot.map[0][i].walls[3] = 1;
   	for(i=1;i<=4;i++)
        robot.map[i][1].walls[2] = 1;
    for(i=1;i<=4;i++)
        robot.map[3][i].walls[1] = 1; 
    print_map();
    /* Phase 1 */

    //Perform depth first search on maze
    //dfs(0, 0, M_PI / 2);

    /* Phase 2 */
    lee(0,1); //Update matrix with Lee costs from node [0,1]

    /* Generate shortest path to node [3,4] (finish line) */
    generate_path(3,4); 

    follow_path(); //Follow the generated path to finish

    //Phew, did we win???

	printf("Ghandy-Bot deactivated!\n");

	return 0;
}