mecatronica [araujo]

Essa página está em modo somente de leitura. Você pode visualizar a fonte, mas não alterá-la. Informe-se com o administrador do Wiki, caso você ache que isso está incorreto.
====== Pós Graduação em Mecatrônica ======

===== Máquina Furador-Cortador =====

main.cpp
<code c>
#include <windows.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include "cortador.h"
#include "furador.h"
#include "manipulador.h"

using namespace std;

int WINAPI WinMain(HINSTANCE hThisInstance, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFunsterStil)
{
    MessageBox(NULL, "Aplicativo Maquina Furador_Cortador", "Controle", MB_OK);

	cortador maquina_corte;
	furador maquina_furo;
	manipulador maquina_manipulador(&maquina_furo,&maquina_corte);

	cout << "Inicio de processamento..." << endl;
	while (1)
	{
		//MessageBox(NULL, "Clique para enviar peça Nova!", "Controle", MB_OK);
		maquina_manipulador.peca_nova();
		_sleep(1000);
	}
	return 0;
}
</code>


manipulador.cpp
<code c>
#include <iostream>
#include "manipulador.h"

int pecas_novas, pecas_furadas, pecas_cortadas, pecas_prontas; //numero de peças esperando para serem processadas.

using namespace std;
//Implementacao do manipulador:

manipulador::manipulador(furador *f,cortador *c){
	   furadorRef=f;
	   cortadorRef=c;
	   pecas_novas=0;
	   pecas_furadas=0;
	   pecas_cortadas=0;
          pecas_prontas=0;

	};

void manipulador::peca_pronta(){
      cout<< "Manipulador -> Recebendo peca pronta! "<<endl;
	  estado=movimento;
	  //levar peca para fora.
	  processa_pecas();
	};
	
void manipulador::peca_furada(){
        cout<< "Manipulador -> Recebendo peca furada! "<<endl;
		processa_pecas();
	};

void manipulador::peca_cortada(){
        cout<< "Manipulador -> Recebendo peca cortada! "<<endl;
		processa_pecas();
	};

void manipulador::peca_nova(){
        cout<< "Manipulador -> Recebendo peca nova! "<<endl;
	    pecas_novas++;
        processa_pecas();
	}
	
void manipulador::processa_pecas()
{
  estado=movimento;
 // while (pecas_novas || pecas_furadas ||pecas_cortadas)
  {
      cout<<endl;
      cout<< "**************Manipulador -> Processando peca !******** "<<endl;
      if (cortadorRef->qual_estado()==cortadorRef->livre)
        cout<< "Cortador Livre"<< endl;
      else
        cout<<"Cortador Ocupado"<<endl;
      if (furadorRef->qual_estado()==furadorRef->livre)
        cout<< "Furador Livre"<< endl;
      else
        cout<<"Furador Ocupado"<<endl;
      cout<< "Pecas novas="<<pecas_novas<<endl;
      cout<< "Pecas furadas="<<pecas_furadas<<endl;
      cout<< "Pecas cortadas="<<pecas_cortadas<<endl;
      cout<< "Pecas prontas="<<pecas_prontas<<endl;
	  if (pecas_furadas!=0 && (cortadorRef->qual_estado()==cortadorRef->livre))
	  { //corta peca ja furada.
			pecas_furadas--;
			cortadorRef->peca_furada();
	  }
	  else if (pecas_cortadas!=0 && (furadorRef->qual_estado()==furadorRef->livre))
	  { //fura peca ja cortada.
			pecas_cortadas--;
			furadorRef->peca_cortada();
	  }
	  else	if (pecas_novas!=0){
                pecas_novas--;
                cout<< "############Decrementando Pecas novas="<<pecas_novas<<endl;
		        if (cortadorRef->qual_estado()==cortadorRef->livre)  //corta peca nova
      			  cortadorRef->peca_nova();
			    else if (furadorRef->qual_estado()==furadorRef->livre)
				  furadorRef->peca_nova();
		    }
	  else {
		 cout<< "Manipulador:repouso"<<endl;
		 estado=repouso;
	 }
  }
}
</code>
manipulador.h
<code c>
#include "furador.h"
#include "cortador.h"
#ifndef MANIPULADOR
#define MANIPULADOR

class manipulador
{
public:
	enum estado_manip {repouso,movimento};
		
private:
	estado_manip estado;
    furador *furadorRef;
    cortador *cortadorRef;
    void processa_pecas();

	//Declaração dos atributos:
public:
	manipulador(furador *f,cortador *c);
	void peca_pronta();
    void peca_furada();
    void peca_cortada();
    void peca_nova();
};
#endif
</code>
cortador.h
<code c>
#ifndef CORTADOR
#define CORTADOR
#define tempo_de_cortar 1 //em segundos

class cortador
	{
private:
	int estado;
//    manipulador *manip;
     void cortar();
//Declaração dos metodos:
public:
	cortador();
	enum {livre, cortando_nova, cortando_furada};
	void peca_nova (void);
	int qual_estado (void);
	void peca_furada (void);

};
#endif

</code>

cortador.cpp
<code c>
#include <windows.h>
#include "cortador.h"
#include <stdlib.h>
#include <iostream>

using namespace std;
extern int pecas_cortadas;
extern int pecas_novas;
extern int pecas_prontas;

int cortando=0;
//Implementacao dos metodos do cortador:
cortador::cortador(){
    estado=livre;
}

DWORD CALLBACK corta_nova(void* Parametro)
{
    cortando=1;
    _sleep(*(int*)Parametro);
    cortando=0;
    pecas_cortadas++;
}

DWORD CALLBACK corta_furada(void* Parametro)
{
    cortando=1;
    _sleep(*(int*)Parametro);
    cortando=0;
    pecas_prontas++;
}

void cortador::cortar(){
     int tempo=tempo_de_cortar;
      DWORD ID_thread;
      HANDLE Meuthread;
    if (estado==cortando_nova)
      Meuthread = CreateThread(
       0,
       0,
       corta_nova,
       &tempo,
       0,
       &ID_thread);
     else
      Meuthread = CreateThread(
       0,
       0,
       corta_furada,
       &tempo,
       0,
       &ID_thread);
    //Caso tenha havido alguma falha
    if(!Meuthread)
    {
        MessageBox(NULL, "Falha em criar o thread!", "Teste", MB_OK);
    }
}
void cortador::peca_nova (void)
{ 
    cout<< "  Cortador:cortando peca nova" <<endl;
	estado = cortando_nova;
	cortar();
 }

void cortador::peca_furada (void)
{
    cout<< "  Cortador:cortando peca furada" <<endl;
	estado = cortando_furada;
	cortar();
}

int cortador::qual_estado (void)
{
  if (cortando==0) //mudou de estado
      estado=livre;
	  switch (estado){
			case livre:	cout<< "  Cortador:Livre" <<endl; break;
			case cortando_nova:	cout<< "  Cortador:Cortador_nova" <<endl; break;	
			case cortando_furada:	cout<< "  Cortador:Cortador_cortada" <<endl;
			}
   return estado;
}

</code>

furador.h
<code c>
#ifndef FURADOR
#define FURADOR
#include <windows.h>
#define tempo_de_furar 1 //em milisegundos

//Definição da classe furador:

class furador
	{
	private:
	int estado;


	//Declaracao dos metodos:
public:
	enum {livre, furando_nova, furando_cortada};
	furador();
	void peca_nova (void);
	int qual_estado (void);
	void peca_cortada (void);
    void furar();
    void executa();
};
#endif
</code>


furador.cpp
<code c>
#include <windows.h>
#include "furador.h"
#include <stdlib.h>
#include <iostream>

#define DEBUG_FURADOR
extern int pecas_furadas;
extern int pecas_novas;
extern int pecas_prontas;

using namespace std;

int furando=0;

//Implementacao do metodos do furador:
furador::furador(){
   estado=livre;
}

void furador::peca_nova (void)
{ 
    cout<< "  Furador:furando peca nova" <<endl;
	estado = furando_nova;
    cout<< "  Furador:peca nova" <<pecas_novas<<endl;
    furar();
 }

void furador::peca_cortada (void)
{
    cout<< "  Furador:furando peca cortada" <<endl;
	estado = furando_cortada;
    furar();
}

int furador::qual_estado (void)
{
  if (furando==0) //mudou de estado
      estado=livre;
       switch (estado){
			case livre:	cout<< "  Furador:Livre" <<endl; break;
			case furando_nova:	cout<< "  Furador:Furando_nova" <<endl; break;	
			case furando_cortada:	cout<< "  Furador:Furando_cortada" <<endl;
			}
  return estado;
}

DWORD CALLBACK fura_nova(void* Parametro)
{
    furando=1;
    _sleep(*(int*)Parametro);
    furando=0;
    pecas_furadas++;
}

DWORD CALLBACK fura_cortada(void* Parametro)
{
    furando=1;
    _sleep(*(int*)Parametro);
    furando=0;
    pecas_prontas++;

}

void furador::furar(){
   int tempo=tempo_de_furar;
   DWORD ID_thread;
   HANDLE Meuthread;
   if (estado==furando_nova)
      Meuthread = CreateThread(
       0,
       0,
       fura_nova,
       &tempo,
       0,
       &ID_thread);
    else
      Meuthread = CreateThread(
       0,
       0,
       fura_cortada,
       &tempo,
       0,
       &ID_thread);
    //Caso tenha havido alguma falha
    if(!Meuthread)
    {
        MessageBox(NULL, "Falha em criar o thread!", "Teste", MB_OK);
    }
}

</code>

===== Programas em C++ =====

[[Programas em C++]]



===== Exercício em C++ =====
=== 1. Classes Pessoa, Aluno e Professor ===

a) Criar classes Pessoa, Aluno e Professor. 
A classe Pessoa deve ter os atributos** nome** e **telefone** e métodos para atribui-los e lê-los.\\
A classe Aluno deve ter atributos **nota** **e matricula**, assim como meodos para manipulá-los.\\
A classe professor deve ter atributos **salario** e **registro** e métodos para manipulá-los.\\
Faça um programa que teste estas propriedades.

b)- Crie construtores para Pessoa, Aluno e Professor.

=== 2. Classes Veiculo, Caminhao e Automovel ===

a) Crie as classes Veiculo, Caminhao e Automovel.\\
Veiculo deve ter atributos motor (int) e n_rodas(int).\\
Caminhao deve ter atributo carga.\\
Automovel deve ter atributo tipo\\
Crie métodos para estas classes\\

b) Crie um construtor para cada uma delas. Crie um construtor vazio, ou seja, que não recebe nenhum parâmetro.

===== Exercício UML =====

Seja um sistema de controle industrial onde uma esteira traz peças que deverão ser inseridas em uma máquina Furador_Cortador (FC). Após a saída dessa máquina a peça terá um corte e um furo, conforme pode ser visto na figura 1 a seguir:

{{f001.png|Figura 1}}

A máquina Furador_Cortador é composta de três outras máquinas internamente: 
  - um Manipulador robótico (M);
  - um Furador (F); e
  - um Cortador (C). 

Veja a figura 2. 

{{f002.png|}}

Após a esteira entregar uma peça à máquina FC, o manipulador robótico coloca tal peça no cortador caso ele esteja livre, senão a peça será colocada no furador se também ele estiver livre. Dessa forma, em um dado momento, é possível termos duas peças no interior da máquina ao mesmo tempo. Uma peça só sairá da máquina FC após ter passado por F e C e uma nova peça só entrará na máquina se tivermos F ou C ou ambos livres.

Mensagens devem ser trocadas entre M, F e C no sentido de se obter o resultado do trabalho da máquina FC, ou seja, uma peça furada e cortada. A tabela a seguir mostra as mensagens trocadas entre M, F e C.

^DIREÇÃO DA MENSAGEM^MENSAGENS|
|M -> F|peça_nova, peça_cortada, qual_estado_atual|
|F -> M|peça_pronta, peça_furada, furando_nova, furando_cortada, livre|
|M -> C|peça_nova, peça_furada, qual_estado_atual|
|C -> M|peça_pronta, peça_cortada, cortando_nova, cortando_furada, livre|

O trabalho consiste em se fazer um modelo com a linguagem UML para este sistema.


==== Solução ====
=== Diagrama de Casos de Uso ===
{{casosdeuso.png|}}
=== Diagrama de Classes ===
{{modelodeclasses.png|Modelo de Classes}}

=== Diagrama de Seqüência ===
{{sequ1.png|}}

===== Trabalho 2007 =====
Seja um sistema de automação como o mostrado na figura a seguir, onde será feita uma reação química de dois produtos (A e B) em um tanque que possui três sensores de níveis: S1 que indica quando o tanque está vazio; S2 que indica quando tanque recebeu a porção do produto A e S3 que indica quando o tanque recebeu a porção da mistura dos produtos A e B (tanque cheio). 

{{f003.png|}}

Após ser feita a reação química que durará um tempo mínimo de tr, o tanque deverá ser lavado com o produto C, fornecido pelo sistema lavador. O processo de lavagem durará um tempo de tl. O controlador do tanque deverá consultar os sistemas fornecedor e lavador para saber da disponibilidade dos seus produtos, assim como, deverá consultar também o sistema coletor para saber se ele pode receber a mistura de A e B.

O controlador do tanque terá acesso aos sensores S1, S2 e S3 e será o responsável por acionar as válvulas para o escoamento de produtos. O sistema fornecedor será o responsável por acionar as válvulas para liberar os produtos A e B, enquanto o sistema lavador será o responsável por acionar a válvula para liberar o produto C.

Faça um modelo com a linguagem UML para especificar este sistema.