main.cpp

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

manipulador.cpp

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

manipulador.h

#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

cortador.h

#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

cortador.cpp

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

furador.h

#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

furador.cpp

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

Programas em C++

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.

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.

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:

A máquina Furador_Cortador é composta de três outras máquinas internamente:

1. um Manipulador robótico (M);
2. um Furador (F); e
3. um Cortador (C).

Veja a figura 2.

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.

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

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).

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.