int main()
{
desenha();
resolve();
desenha();
return 0;
}
/* Função que desenha as caixas dos nós e as linhas de ligação entre os pais e os filhos */
void desenha(PNo raiz,int nivel,int deslocamento, int x_pai) {
int x, y;
if (raiz != NULL) {
x = ((raiz->tamanho_total-nDigitos(raiz->chave))/2)+deslocamento; /* calcula a coluna em que o nó deve ser desenhado */
y = nivel*4; /* calcula a linha em que digito deve ser desenhado */
box(y,x,raiz->chave,0,15); /* desenha o nó */
if(x_pai != -1) { /* se o nó tiver pai */
line(x+(nDigitos(raiz->chave)/2),y-1,x_pai,((nivel-1)*4)+1); /* desenha a linha ligando o nó ao pai */
}
if(raiz->irmao) desenha(raiz->irmao,nivel,(raiz->tamanho_total)+deslocamento,x_pai); /* chama mesma função para desenhar o irmão desse nó */
if(raiz->filho) desenha(raiz->filho,nivel+1,deslocamento,x+(nDigitos(raiz->chave)/2)); /* chama a mesma função para desenhar o filho desse nó */
}
}
void Jogo::run()
{
intro();
sf::Clock clock;
gui.clk_esteira.restart();
geraFila();
sf::Time timeSinceLastUpdate = sf::Time::Zero;
score.restart();
gui.musicaFundo.play();
while(gui.tela.isOpen() && this->level < 6)
{
timeSinceLastUpdate += clock.restart();
if(timeSinceLastUpdate > timePerFrame)
{
processaEventos();
if(!jogo_paused)
{
atualizaEstado();
desenha();
}
timeSinceLastUpdate = sf::Time::Zero;
}
}
encerramento();
}
void resolve()
{
int topo, passos, x, y;
item atual;
item pilha[32];
topo = 0; passos = 0; x = 0; y = 0;
atual.pos.x = 0; atual.pos.y = 0;
atual = procura( atual, &x, &y );
while ( ganhou() ) {
getchar();
printf("X = %d Y = %d Mov = %d x = %d y = %d P = %d \n", atual.pos.x, atual.pos.y, atual.mov, x, y, passos);
desenha();
while ( atual.mov <= 4 ) {
if ( podemov(atual) ) {
printf("Empilhando - \n");
empilha( pilha, &topo, atual );
atualizatab( atual, &atual );
x = 0;
y = 0;
passos++;
getchar();
printf("X = %d Y = %d Mov = %d x = %d y = %d P = %d \n", atual.pos.x, atual.pos.y, atual.mov, x, y, passos);
desenha();
}
else atual.mov++;
}
if ( atual.mov > 4 ) {
if ( x >= 6 && y >= 4 ) {
if ( topo == 0 ) {
printf("Sem Solucao.");
break;
}
else {
printf("Backtrack - \n");
atual = topodapilha( pilha, topo );
desatualizatab( atual );
x = atual.pos.x;
y = atual.pos.y;
atual.mov++;
desempilha( &topo );
passos--;
}
}
}
}
imprimesol(pilha, topo);
}
void resolve()
{
int mov, topo, passos, x,y;
item local, aux;
posicao atual;
item pilha[32];
topo = 0; passos = 1; x = 0, y = 0, mov = 1;
atual.x = 3; atual.y = 3;
local.pos.x = 0; local.pos.y = 0; local.mov = 1;
while ( passos < 32 ) {
while ( mov <= 4 ) {
desenha();
printf(" %d ", podemov( atual, mov ) );
if ( podemov( &atual, mov ) ) {
printf("Testando uma posicao... \n ");
break;
}
else mov++;
}
if ( mov < 5 ) {
local.pos.x = atual.x;
local.pos.y = atual.y;
local.mov = mov;
printf("Empilhando uma posicao... \n");
empilha( pilha, &topo, local );
x = 0; y = 0;
passos++;
mov = 1;
}
else if ( mov == 5 ) {
printf("Procurando uma posicao... \n");
for ( ; x < MAX, x++ ) {
for ( ; y < MAX, y++ ) {
if ( achaoutro( x, y ) ) {
atual.x = x;
atual.y = y;
break;
}
}
}
}
if ( x == 6 && y == 6 && mov == 5 ) {
if ( topo == 0 ) printf("Sem Solucao. /n");
else {
aux = topodapilha( pilha, topo );
atual.x = aux.pos.x;
atual.y = aux.pos.y;
mov = aux.mov + 1;
passos--;
printf("Desempilhando uma posicao... \n");
desempilha( &topo );
}
}
}
void Jogo::loop()
{
while (janela.isOpen()) {
desenha();
/* Teclas de efeito contínuo */
keyOperations();
/* Trata possíveis eventos do SFML */
sf::Event evento;
while (janela.pollEvent(evento)) {
switch (evento.type) {
case sf::Event::Closed:
/* Fechamento da janela (Alt+F4, etc) */
janela.close();
break;
case sf::Event::KeyPressed:
/* Pressionamento não contínuo de tecla */
keyPressOperations(evento.key.code);
break;
case sf::Event::Resized:
/* Redimensionamento da janela */
remodela();
break;
case sf::Event::LostFocus:
/* Pausa jogo ao alternar para outra janela */
pausado = true;
break;
default: break;
}
}
/* Atualiza jogo e elementos do cenário */
if (pausado) continue;
if (not Cenario::get().atualiza()) janela.close();
}
printf("Score final: %d\n", nave->getScore());
}
/*metodo principal, gerencia a janela*/
int main(int argc, char argv[]) {
/*janela principal*/
ALLEGRO_DISPLAY *janela = NULL;
/*fila de eventos*/
ALLEGRO_EVENT_QUEUE *filaEvento = NULL;
/*evento atual*/
ALLEGRO_EVENT evento;
ALLEGRO_BITMAP *botao_gravar = NULL, *botao_carregar = NULL, *botao_girar_horario = NULL, *botao_girar_antihorario = NULL;
/*ponteiro para um arquivo no dico*/
FILE *arquivo;
/*definicoes do arquivo*/
int altura = 0,//altura da imagem
largura = 0, //largura da imagem
maxCor = 0;//inteiro que representa tonalidade de cor maxima
char tipo[3];//tipo de PGM
/*estrutura para armazenar os bits do arquivo*/
unsigned char **data = NULL;
/*sinaliza fechamento da janela*/
bool fechaJanela = false;
/*sinaliza existencia de arquivo aberto*/
bool arquivoAberto = false;
/*inicializa bibliotecas*/
if(!(al_init() &&
al_install_mouse()&&
al_init_image_addon()&&
al_install_keyboard()&&
al_init_primitives_addon()&&
(filaEvento = al_create_event_queue()))){
printf("Erro ao inicializar biblioteca(s)!\n");
return 0;
}
// Alocamos o botão para fechar a aplicação
criaBotao(botoes[0], "carregar.bmp");
botao_carregar = al_load_bitmap("carregar.bmp");
if (!botao_carregar)
{
fprintf(stderr, "Falha ao criar botão de carregar a imagem.\n");
al_destroy_display(janela);
return -1;
}
// Alocamos o botão para fechar a aplicação
botao_gravar = al_load_bitmap("salvar.bmp");
if (!botao_gravar)
{
fprintf(stderr, "Falha ao criar botão de salvar a imagem.\n");
al_destroy_bitmap(botao_carregar);
al_destroy_display(janela);
return -1;
}
// Alocamos o botão para fechar a aplicação
botao_girar_horario = al_load_bitmap("girar_horario.bmp");
if (!botao_girar_horario)
{
fprintf(stderr, "Falha ao criar botão de girar a imagem 90º sentido horario.\n");
al_destroy_bitmap(botao_carregar);
al_destroy_bitmap(botao_gravar);
al_destroy_display(janela);
return -1;
}
// Alocamos o botão para fechar a aplicação
botao_girar_antihorario = al_load_bitmap("girar_anti.bmp");
if (!botao_girar_antihorario)
{
fprintf(stderr, "Falha ao criar botão de girar a imagem 90º sentido anti-horario.\n");
al_destroy_bitmap(botao_carregar);
al_destroy_bitmap(botao_gravar);
al_destroy_bitmap(botao_girar_horario);
al_destroy_display(janela);
return -1;
}
/*cria uma janela 640x480*/
janela = al_create_display(640, 50);
/*registra os eventos*/
al_register_event_source(filaEvento, al_get_display_event_source(janela));
al_register_event_source(filaEvento, al_get_mouse_event_source());
al_register_event_source(filaEvento, al_get_keyboard_event_source());
/*preenche a janela com a cor branca*/
al_clear_to_color(al_map_rgb(255, 255, 255));
/*atualiza tela*/
al_flip_display();
/*fluxo principal da janela*/
while(fechaJanela == false){
/*pega evento da fila*/
al_wait_for_event(filaEvento, &evento);
switch (evento.type) {
/*fecha a janela (termina aplicacao)*/
case ALLEGRO_EVENT_DISPLAY_CLOSE:
fechaJanela = true;
break;
/*carrega imagem em mostra na tela*/
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
if (evento.mouse.x >= 0 && evento.mouse.x <= 70 && evento.mouse.y <= 50 && evento.mouse.y >= 0) {
/*caso algum arquivo estiver aberto, limpa dados*/
if(arquivoAberto==true) {
desalocaMatriz(data, altura);
altura =0;
largura =0;
maxCor =0;
arquivoAberto = false;
}
if(arquivoAberto==false) {
/*carrega imagem na matriz*/
if(carregaImagem (janela, &altura,&largura, &maxCor, tipo, &data)==-1) {
printf("Erro ao desenhar imagem!\n");
break;
}
/*sinaliza como arquivo aberto*/
arquivoAberto = true;
/*desenha a imagem na janela*/
desenha(janela, data, altura, largura);
}
}
if (evento.mouse.x >= 71 && evento.mouse.x <= 140 && evento.mouse.y <= 50 && evento.mouse.y >= 0 && arquivoAberto== true){
if(arquivoAberto == true) {
if(gravaImagem(janela, tipo, altura, largura, maxCor, data)==-1) {
printf("Erro ao salvar imagem!\n");
break;
}
}
else {
printf("Nenhum arquivo aberto!\n");
}
}
if (evento.mouse.x >= 141 && evento.mouse.x <= 210 && evento.mouse.y <= 50 && evento.mouse.y >= 0 && arquivoAberto== true)
{
data = rotacao(data, &altura, &largura, 'D');
desenha(janela, data, altura, largura);
}
if (evento.mouse.x >= 211 && evento.mouse.x <= 280 && evento.mouse.y <= 50 && evento.mouse.y >= 0 && arquivoAberto== true){
data = rotacao(data, &altura, &largura, 'E');
desenha(janela, data, altura, largura);
}
break;
case ALLEGRO_EVENT_KEY_DOWN:
switch(evento.keyboard.keycode)
{
case ALLEGRO_KEY_ENTER:
if(arquivoAberto == true) {
if(gravaImagem(janela, tipo, altura, largura, maxCor, data)==-1) {
printf("Erro ao salvar imagem!\n");
break;
}
}
else {
printf("Nenhum arquivo aberto!\n");
}
break;
case ALLEGRO_KEY_SPACE:
data = rotacao(data, &altura, &largura, 'D');
desenha(janela, data, altura, largura);
break;
}
default:
break;
}
al_set_target_bitmap(botao_gravar);
al_set_target_bitmap(botao_carregar);
al_set_target_bitmap(botao_girar_horario);
al_set_target_bitmap(botao_girar_antihorario);
al_set_target_bitmap(al_get_backbuffer(janela));
al_draw_bitmap(botao_carregar, 0,0, 0);
al_draw_bitmap(botao_gravar, 71,0, 0);
al_draw_bitmap(botao_girar_horario, 141,0, 0);
al_draw_bitmap(botao_girar_antihorario, 211,0, 0);
/*atualiza tela*/
al_flip_display();
}
/*limpeza*/
if(data!=NULL && arquivoAberto == true){
desalocaMatriz(data, altura);
}
al_destroy_event_queue(filaEvento);
al_uninstall_mouse();
al_uninstall_keyboard();
al_destroy_bitmap(botao_carregar);
al_destroy_bitmap(botao_gravar);
al_destroy_bitmap(botao_girar_horario);
al_destroy_bitmap(botao_girar_antihorario);
al_destroy_display(janela);
return 0;
}
int main(int argc, char const *argv[])
{
string reader,read;
int leitor;
SDL_Surface * superficie;
bool rodando = true;
bool pronto = false;
cin>> reader >> leitor;
if (reader.compare("*Vertices") == 0)
{
Grafo *g = new Grafo(leitor);
cin>> read;
while (read.compare("*Arcs") != 0 && read.compare("*Edges") != 0)
{
leitor = atoi(read.c_str());
cin>> reader;
g->inserirVertice(leitor,reader);
cin>> read;
}
bool flag;
if (read.compare("*Arcs") == 0)
{
g->setDirecionado(false);
flag = false;
}
else
{
if (read.compare("*Edges") == 0)
{
g->setDirecionado(true);
flag = true;
}
else
{
cout<< "Entrada Invalida "<<endl;
return 1;
}
}
cin>> read;
while(read.compare("@") != 0)
{
int Id1, Id2, peso;
Id1 = atoi(read.c_str());
cin>> read;
Id2 = atoi(read.c_str());
cin>> read;
peso = atoi(read.c_str());
if (flag == false)
{
g->inserirAresta(Id1,Id2,peso);
}
else
{
g->inserirAresta(Id1,Id2,peso);
g->inserirAresta(Id2,Id1,peso);
}
cin>> read;
}
g->inserirAresta(0,0,INT_MIN);
SDL_Init (SDL_INIT_EVERYTHING);
TTF_Init();
superficie = SDL_SetVideoMode (LARGURA, ALTURA, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
bool flag2 = false;
bool flag3 = false;
while(rodando) {
SDL_Event evento;
SDL_PollEvent(&evento);
if (!pronto) {
pronto = !g->calcula();
desenha (superficie, g,flag2,flag3);
} else {
SDL_Delay(1);
}
if (evento.type == SDL_QUIT) {
SDL_FreeSurface(superficie);
SDL_Quit();
rodando = 0;
} else {
if (evento.type == SDL_KEYDOWN)
{
if (evento.key.keysym.sym == SDLK_n)
{
SDL_Delay(150);
flag2 = !flag2;
pronto = false;
}
if (evento.key.keysym.sym == SDLK_p)
{
SDL_Delay(150);
flag3 = !flag3;
pronto = false;
}
}
}
}
}
/* Função que chama a função recursiva de desenho */
void desenhaArvore(PNo tree, int deslocamento) {
desenha(tree,1,deslocamento,-1);
}
int main()
{
ufrn_header();
// INICIO DO PROGRAMA DEMO //
printf("PROGRAMA INTOLERANTS INICIADO\n\n");
serial_fd = abrir_porta();
if (serial_fd == -1)
{
printf("Erro abrindo a porta serial /dev/ttyS0\nAbortando o programa...");
return -1;
}
else
{
printf("Porta serial /dev/ttyS0 aberta com sucesso\n");
if (configurar_porta(serial_fd) == -1)
{
printf("Erro inicializando a porta\n");
close(serial_fd);
return -1;
}
comando = (char*) malloc(sizeof(char) * BUFSIZE);
last_comando = (char*) malloc(sizeof(char) * BUFSIZE);
//////////////////////
// PRIMEIRO COMANDO //
//////////////////////
printf("\nPRIMEIRO COMANDO - POSICAL INICIAL\n");
sprintf(comando, "%s", STANDBY);
//Escrevendo com teste de escrita
if (enviar_comando(comando, serial_fd) != -1)
{
printf("Enviando de comando com teste de envio: %s\n", STANDBY);
}
else
{
printf("Problema no envio do comando\nAbortando o programa...");
return -1;
}
printf("Pressione enter para continuar...");
getchar();
memset(comando, 0, BUFSIZE);
sprintf(comando, "%s", HOME_POS);
//Escrevendo com teste de escrita
if (enviar_comando(comando, serial_fd) != -1)
{
printf("Enviando de comando com teste de envio: %s\n", HOME_POS);
}
else
{
printf("Problema no envio do comando\nAbortando o programa...");
return -1;
}
memset(comando, 0, BUFSIZE);
/////////////////////
// SEGUNDO COMANDO //
/////////////////////
//system("rm input.txt");
//system("cat /dev/null > input.txt");
//system("rm pos.txt");
//system("cat /dev/null > pos.txt");
do {
if(system ("clear"));
t1 = angSenseBas*PI/180;
t2 = angSenseShl*PI/180;
t3 = angSenseElb*PI/180;
t4 = angSenseWri*PI/180;
X = cos(t1)*(L3*cos(t2 + t3) + L2*cos(t2) + L4*cos(t2 + t3 + t4));
Y = sin(t1)*(L3*cos(t2 + t3) + L2*cos(t2) + L4*cos(t2 + t3 + t4));
Z = L1 + L3*sin(t2 + t3) + L2*sin(t2) + L4*sin(t2 + t3 + t4);
calc_tetas(X, Y, Z, phi);
printf("A coordenada x do ponto : %.2f \n", X);
printf("A coordenada y do ponto : %.2f \n", Y);
printf("A coordenada z do ponto : %.2f \n", Z);
printf("phi da ferramenta : %.2f \n", angSenseShl+angSenseElb+angSenseWri);
//printf("#0P%dS%d#1P%dS%d#2P%dS%d#3P%dS%d#4P%dS%dT%d\n", (int)sense[0], s, (int)sense[1], s, (int)sense[2], s, (int)sense[3], s, (int)sense[4], s, t);
printf("%s\n", last_comando);
printf("BASE -> (Q)ESQUERDA ; (A)DIREITA | LARGURA DO PULSO: %.2f \t | ANGULO: %.2f \t | ANGULOC: %.2f \n", sense[0], angSenseBas, teta[0]);
printf("OMBRO -> (W)CIMA ; (S)BAIXO | LARGURA DO PULSO: %.2f \t | ANGULO: %.2f \t | ANGULOC: %.2f \n", sense[1], angSenseShl, teta[1]);
printf("COTOVELO -> (E)CIMA ; (D)BAIXO | LARGURA DO PULSO: %.2f \t | ANGULO: %.2f \t | ANGULOC: %.2f \n", sense[2], angSenseElb, teta[2]);
printf("PUNHO -> (R)CIMA ; (F)BAIXO | LARGURA DO PULSO: %.2f \t | ANGULO: %.2f \t | ANGULOC: %.2f \n", sense[3], angSenseWri, teta[3]);
printf("GARRA -> (T)FECHAR ; (G)ABRIR | LARGURA DO PULSO: %d \t \n", (int)sense[4]);
printf("Digite space para sair\n");
if(system("/bin/stty raw"));
c = getchar();
if(system("/bin/stty cooked"));
if (c == 'q') {
sense[0] = sense[0] + 2;
pos = sense[0];
angSenseBas = (offsetBas - sense[0]) * gainBas;
sprintf(comando, "#%dP%d", BAS_SERVO, trava(BAS_SERVO, pos));
} else if (c == 'a') {
sense[0] = sense[0] - 2;
pos = sense[0];
angSenseBas = (offsetBas - sense[0]) * gainBas;
sprintf(comando, "#%dP%d", BAS_SERVO, trava(BAS_SERVO, pos));
} else if (c == 'w') {
sense[1] = sense[1] + 2;
pos = sense[1];
// angSenseShl = (sense[1] - offsetShl) * gainShl;
angSenseShl = 762.684+7.948*sense[1];
sprintf(comando, "#%dP%d", SHL_SERVO, pos * (pos < 1850) + 1850 * (pos >= 1850));
} else if (c == 's') {
sense[1] = sense[1] - 2;
pos = sense[1];
// angSenseShl = (sense[1] - offsetShl) * gainShl;
angSenseShl = 762.684+7.948*sense[1];
sprintf(comando, "#%dP%d", SHL_SERVO, pos * (pos < 1850) + 1850 * (pos >= 1850));
} else if (c == 'e') {
sense[2] = sense[2] - 2;
pos = sense[2];
// angSenseElb = (offsetElb - sense[2]) * gainElb - 180;
angSenseElb = 854.377-9.231*sense[2];
sprintf(comando, "#%dP%d", ELB_SERVO, pos);
} else if (c == 'd') {
sense[2] = sense[2] + 2;
pos = sense[2];
// angSenseElb = (offsetElb - sense[2]) * gainElb - 180;
angSenseElb = 854.377-9.231*sense[2];
sprintf(comando, "#%dP%d", ELB_SERVO, pos);
} else if (c == 'r') {
sense[3] = sense[3] + 2;
pos = sense[3];
// angSenseWri = (sense[3] - offsetWri) * gainWri - 90;
angSenseWri = 1465.639+10.114*sense[3];
sprintf(comando, "#%dP%d", WRI_SERVO, trava(WRI_SERVO, pos));
} else if (c == 'f') {
sense[3] = sense[3] - 2;
pos = sense[3];
// angSenseWri = (sense[3] - offsetWri) * gainWri - 90;
angSenseWri = 1465.639+10.114*sense[3];
sprintf(comando, "#%dP%d", WRI_SERVO, trava(WRI_SERVO, pos));
} else if (c == 't') {
sense[4] = sense[4] + 10;
pos = sense[4];
sprintf(comando, "#%dP%d", GRI_SERVO, trava(GRI_SERVO, pos));
} else if (c == 'g') {
sense[4] = sense[4] - 10;
pos = sense[4];
sprintf(comando, "#%dP%d", GRI_SERVO, trava(GRI_SERVO, pos));
} else if (c == 'p') {
if(system("gnome-terminal -x /home/aluno/intolerants/meta3/meta3"));
} else if (c == '=') {
FILE *f = fopen("input.txt", "a");
if (f == NULL)
{
printf("Error opening file!\n");
exit(1);
}
/* print some text */
fprintf(f, "%d %d\n", (int)X+OFFSETX, (int)Y+OFFSETY);
fclose(f);
FILE *f2 = fopen("pos.txt", "a");
if (f2 == NULL)
{
printf("Error opening file!\n");
exit(1);
}
/* print some text */
fprintf(f2, "#0P%uT1000#1P%uT1000#2P%uT1000#3P%uT1000#4P%uT1000\n", (unsigned int)sense[0], (unsigned int)sense[1], (unsigned int)sense[2], (unsigned int)sense[3], (unsigned int)sense[4]);
fclose(f2);
} else if (c == 'b') {
int *bolas, i, n;
printf("\nDigite quantas bolinhas:\n");
scanf("%d", &n);
bolas = malloc(n*sizeof(int));
printf("\nDigite a ordem das bolinhas:\n");
for (i = 0; i < n; i++)
scanf("%d", &bolas[i]);
//bolas[i] = i+1;
desenha(bolas, n);
} else if (c == '0') {
// sense[0] = 1528;
// sense[1] = 1796;
// sense[2] = 2072;
// sense[3] = 844;
// sense[4] = 1870;
// // send_command(1528,1796,2072,844,1870);
// int delay = 2000;
// sprintf(comando,"#0P%dT%d#1P%dT%d#2P%dT%d#3P%dT%d#4P%dT%d", sense[0], s, sense[1], s, sense[2], s, sense[3], s, sense[4], s, t);
repouso();
} else if (c == '1') {
move(2.97,-22.55,9,-5);
sleep(3);
move(6.02,-27.16,9.63,-10.38);
sleep(3);
} else if (c == 'h') {
printf("Insira s e t: ");
if(scanf("%d", &s));
if(scanf("%d", &t));
sprintf(comando, "#0P1528S%d#1P1468S%d#2P1672S%d#3P1504S%d#4P1870S%dT%d", s, s, s, s, s, t);
} else if (c == 'z') {
pega();
// getchar();
} else if (c == 'x') {
solta();
// printf("solta\n");
// getchar();
} else if (c == 'm'){
printf("\n\n");
printf("x: ");
if(scanf("%f", &x));
printf("y: ");
if(scanf("%f", &y));
printf("z: ");
if(scanf("%f", &z));
printf("phi: ");
if(scanf("%f", &phi));
move(x,y,z,phi);
printf("%s\n", comando);
}
if (enviar_comando(comando, serial_fd) != -1)
{
printf("\nEnviando de comando com teste\n");
}
else
{
printf("Problema no envio do comando\nAbortando o programa...");
return -1;
}
// while ( (c = getchar()) != '\n');
memset(comando, 0, BUFSIZE);
} while ( c != ' ');
sprintf(comando, "%s", STANDBY);
enviar_comando(comando, serial_fd);
memset(comando, 0, BUFSIZE);
printf("Pressione enter para relaxar...");
getchar();
sprintf(comando, "%s", RELAX);
enviar_comando(comando, serial_fd);
// FIM DO PROGRAMA DEMO //
fechar_porta(serial_fd);
printf("\nAcesso a porta serial /dev/ttyS0 finalizado\n");
}
printf("\nPROGRAMA FINALIZADO\n\n");
return 0;
}
