segunda-feira, 22 de dezembro de 2014

Semáforo Com Potenciômetro no Arduino

Utilizando os componentes abaixo construir um simulador de semáforos com sinal de pedestre, onde um potenciômetro controlará a velocidade das luzes do semáforo.
  • Componentes 3 LEDs(verde, amarelo, vermelho);
  • Potenciômetro – (o disponível no momento era de 10K);
  • 3 resistores delimitadores;
  • Arduino.
Montagem Hardware: 

Código no Arduino:


int tempoDeEspera; 

int sinalVermelho = 7;
int sinalAmarelo = 5;
int sinalVerde = 3;
int potenciometro = 2;

void setup() {
  pinMode(sinalVermelho, OUTPUT);
  pinMode(sinalAmarelo, OUTPUT);
  pinMode(sinalVerde, OUTPUT);
}

void loop() {
  tempoDeEspera = analogRead(potenciometro);//o tempo de espera é igual a leitura analogica do potenciometro
  
  /*Daqui para baixo é comportamento de um sinal de trânsito 
  em delay(tempoDeEspera), vai sempre pegar o valor do tempo de espera, que por sua vez pega os valores do potenciômetro*/
  
  digitalWrite(sinalVermelho, HIGH); //Acende sinal vermelho e espera um tempinho 
  delay(tempoDeEspera);   
  
  digitalWrite(sinalAmarelo, HIGH); // Acende sinal amarelo, enquanto o vermelho também está ligado e espera
  delay(tempoDeEspera); 
  
  //Nas quatro linhas a seguir: acende verde, apaga vermelho, apaga amarelo e espera
  digitalWrite(sinalVerde, HIGH); 
  digitalWrite(sinalVermelho, LOW);
  digitalWrite(sinalAmarelo, LOW); 
  delay(tempoDeEspera); 
  
  //Acende amarelo e apaga verde e espera
  digitalWrite(sinalAmarelo, HIGH);
  digitalWrite(sinalVerde, LOW); 
  delay(tempoDeEspera);
  
  //Apaga amarelo ao "mesmo tempo" que acende o vermelho no início do loop
  digitalWrite(sinalAmarelo, LOW); 
}
Postado por às Nenhum comentário:
Marcadores: , ,

terça-feira, 9 de dezembro de 2014

Considere um Sistema de Controle de Pagamentos de Funcionários de uma empresa.

Esse sistema apresenta uma classe chamada Pagamento, com os atributos valorPagamento, do tipo double e nomeDoFuncionario, do tipo String e métodos para obter e alterar esses atributos (métodos get e set).
Esse sistema apresenta também uma classe ControleDePagamentos, que apresenta um atributo chamado pagamentos, que é um array de objetos do tipo Pagamento e o método setPagamentos. Essa classe apresenta também um método chamado calculaTotalDePagamentos, que não tem parâmetros e deve retornar o valor total dos pagamentos do sistema. Nessa classe há ainda o método existePagamentoParaFuncionario (String nomeFuncionario) que verifica se dentre os pagamentos guardados no ControleDePagamentos há algum deles que se refere ao funcionário passado como parâmetro, retornando true neste caso e false, caso contrario.

a) Implemente a classe Pagamento.
b) Implemente a classe ControleDePagamentos.
c) Escreva um programa principal que crie um objeto do tipo ControleDePagamentos e que tenha ao menos dois pagamentos. Faça com que o programa imprima o total dos pagamentos utilizando o método correspondente da classe ControleDePagamentos.

Feito:

public class Pagamento{
    private double valorPagamento;
    private String nomeDoFuncionario;

    public double getValorPagamento() {
        return valorPagamento;
    }
    public void setValorPagamento(double valorPagamento) {
        this.valorPagamento = valorPagamento;
    }

    public String getNomeDoFuncionario() {
        return nomeDoFuncionario;
    }
    public void setNomeDoFuncionario(String nomeDoFuncionario) {
        this.nomeDoFuncionario = nomeDoFuncionario;
    }       
}
  
//b)
public class ControleDePagamento{
    private Pagamento pagamentos[] = new Pagamento[2];
   
    public void setPagamentos(Pagamento pagamentos[]){
        this.pagamentos = pagamentos;
    }
   
    public double calculaTotalDePagamentos(){
        double total=0;      
        for(int i = 0; i < pagamentos.length; i++){
            total+=pagamentos[i].getValorPagamento();
        }    
        return total;
    }
   
    public boolean existePagamentoParaFuncionarios(String funcionario){
        for(int i = 0; i < pagamentos.length; i++){
            if(funcionario == pagamentos[i].getNomeDoFuncionario()){
                return true;
            }
        }
        return false;
    }
}

//c)
public class SistemaDePagamentos{
    public static void main(String[] args){
        Pagamento arrayPagamentos[] = new Pagamento[2];
        arrayPagamentos[0] = new Pagamento();
        arrayPagamentos[0].setNomeDoFuncionario("João");
        arrayPagamentos[0].setValorPagamento(15000.00);
       
        arrayPagamentos[1] = new Pagamento();       
        arrayPagamentos[1].setNomeDoFuncionario("Laura");
        arrayPagamentos[1].setValorPagamento(21750.00);
       
        ControleDePagamento pagamentosTotais = new ControleDePagamento();
        pagamentosTotais.setPagamentos(arrayPagamentos);
       
        System.out.println("Total das despesas: " + pagamentosTotais.calculaTotalDePagamentos());
        System.out.println("Pagamento João? " + pagamentosTotais.existePagamentoParaFuncionarios("João")
                          +"\naPagamento Rodrigo? " + pagamentosTotais.existePagamentoParaFuncionarios("Rodrigo"));
    }

}
Postado por às Nenhum comentário:
Marcadores: , , ,

Considere um Sistema de Controle de Gastos de Mesada. Esse sistema apresenta uma classe chamada Despesa

Considere um Sistema de Controle de Gastos de Mesada. Esse sistema apresenta uma classe chamada Despesa, com os atributos valor, do tipo double e tipoDeGasto, do tipo String e métodos para obter e alterar esses atributos (métodos get e set).
Esse sistema apresenta também uma classe ControleDeGastos, que apresenta um atributo chamado despesas, que é um array de objetos do tipo Despesa e o método setDespesas. Essa classe apresenta também um método chamado calculaTotalDeDespesas, que não tem parâmetros e deve retornar o valor total das despesas do sistema. Nessa classe há ainda o método existeDespesaDoTipo(String tipoDeGasto) que verifica se dentre as despesas guardadas no ControleDeGastos há alguma delas que é do tipo passado retornando true neste caso e false, caso contrario.

a) Implemente a classe Despesa.
b) Implemente a classe ControleDeGastos.
c) Escreva um programa principal que crie um objeto do tipo ControleDeGastos e que tenha ao menos duas despesas. Faça com que o programa imprima o total das despesas utilizando o método correspondente da classe ControleDeGastos.


public class Despesa{
    private double valor;
    private String tipoDeGasto;   
   
    Despesa(String tipoDeGasto, double valor){
        this.tipoDeGasto = tipoDeGasto;
        this.valor = valor;
    }

    public double getValor() {
        return valor;
    }
    public void setValor(double valor) {
        this.valor = valor;
    }

    public String getTipoDeGasto() {
        return tipoDeGasto;
    }
    public void setTipoDeGasto(String tipoDeGasto) {
        this.tipoDeGasto = tipoDeGasto;
    }

}

//b)
public class ControleDeGastos{
    private Despesa despesas[] = new Despesa[2];
   
    public void setDespesas(Despesa despesas[]){
        this.despesas = despesas;
    }

    public double calculaTotalDeDespesas(){
        double total=0;
       
        for(int i = 0; i < despesas.length; i++){
            total+=despesas[i].getValor();
        }      return total;
    }
   
    public boolean existeDespesaDoTipo(String tipoDeGasto){
        for(int i = 0; i < despesas.length; i++){
            if(tipoDeGasto == despesas[i].getTipoDeGasto()){
             return true;
            }
        } return false;}}

//c)
public class Gastos{
    public static void main(String[] args){
        Despesa arrayDespesas[] = new Despesa[2];
        arrayDespesas[0] = new Despesa("passagem", 80.15);
        arrayDespesas[1] = new Despesa("jogo", 100.00);
       
        ControleDeGastos despesasTotais = new ControleDeGastos();
        despesasTotais.setDespesas(arrayDespesas);
       
        System.out.println("Total das despesas: " + despesasTotais.calculaTotalDeDespesas());
        System.out.println("alguma despesa com apostila? " + despesasTotais.existeDespesaDoTipo("apostila")
                          +"\nalguma despesa com passagem? " + despesasTotais.existeDespesaDoTipo("passagem"));
    }
}
Postado por às Nenhum comentário:
Marcadores: , , ,

Considere o seguinte trecho de código da classe Boneco:

public class Boneco {
private String nome;
private int idade;
private int posicaoX;
private int posicaoY;
private String cor;
public int getPosicaoX() {
return this.posicaoX;
}
public int getPosicaoY() {
return this.posicaoY;
}
public void setPosicao(int novoX, int novoY) {
this.posicaoX = novoX;
this.posicaoY = novoY;
}
}

a)Considerando a classe Boneco acima, quais os atributos (variáveis de instância ou campos) dessa classe?
b) Crie os métodos getNome, setNome, getIdade e setIdade da classe Boneco.
c) Crie um programa principal chamado MeuJogo e lá crie duas instâncias de bonecos, um
chamado “João”, outro chamado “Zé”, tendo João 3 anos e Zé 5 anos. João deve estar na posição x=10, y=80 e Zé deve estar na posição x=50, y=60.
d) Crie um outro programa principal MeuJogo2 e que deve ler do usuário os seguintes dados de “N” bonecos: nome e idade. A quantidade “N” de bonecos deve também ser fornecida pelo usuário do programa e os bonecos devem ser guardados em um array. Depois de ler os “N” bonecos, o programa deve imprimir a idade do boneco mais novo que foi lido.

//Classe Boneco:
//a) São os atributos: nome, idade, posição x, posição y e cor.

//b)public String getNome() {
        return nome;
    }
    public void setNome(String nome) {
        this.nome = nome;
    }

    public int getIdade() {
        return idade;
    }
    public void setIdade(int idade) {
        this.idade = idade;
    }

//c) Criando um método construtor em class Boneco:
            Boneco(String n_nome, int n_idade, int novoX, int novoY)
            {
                        this.nome = n_nome;
                        this.idade = n_idade;
                        this.posicaoX = novoX;
                        this.posicaoY = novoY;
            }

podemos instanciar os bonecos no main da seguinte forma:
public class MeuJogo{          
            public static void main(String args[]){
                        Boneco boneco1 = new Boneco("João", 3, 10, 80);
                        Boneco boneco2 = new Boneco("Zé", 5, 50, 60);
            }
}

//d)Implementação de MeuJogo2: 
import java.util.Scanner;

public class Vai{
    public static void main(String args[]){
        Scanner input = new Scanner(System.in);
        int idade;
        String nome;
        int MIN = 999;
        int guardIndex = 0;
        int N = input.nextInt();
        Boneco bonecos[] = new Boneco[N];
       
        for(int i = 0; i < bonecos.length; i++){
            nome = input.next();
            idade = input.nextInt();
            bonecos[i] = new Boneco(nome, idade, 0, 0);
            if(idade < MIN){
                MIN = idade;
                guardIndex = i;
            }
        }
       
        System.out.println("A menor idade é a do boneco: "
                            + bonecos[guardIndex].getNome()
                            +" com " +bonecos[guardIndex].getIdade()+ " Anos");
       
    }

}


Postado por às Nenhum comentário:
Marcadores: , , ,

Considere um sistema que possui uma classe Pessoa e uma classe CadastroDePessoas, (a) Implemente uma classe Pessoa que possui os atributos:

atributos nome (do tipo String), idade (do tipo int) e telefone (do tipo String). Considere também que ela possui dois construtores (um que só recebe o nome e outro que recebe nome, idade e telefone) e métodos para obter e alterar esses atributos (métodos get e set).

(b) Em seguida, crie uma classe principal CadastroDePessoas com o método main que cria dois objetos do tipo Pessoa e configura os valores de nome, idade e telefone desses objetos.

Feito:

//Classe pessoa:
public class Pessoa{
    private String nome, telefone;
    private int idade;    
   
    Pessoa(String nome){
        this.nome = nome;
    }
    Pessoa(String nome, int idade, String telefone){
        this.nome = nome;
        this.idade = idade;
        this.telefone = telefone;
    }

    public String getNome() {
        return nome;
    }
    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getTelefone() {
        return telefone;
    }
    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }

    public int getIdade() {
        return idade;
    }
    public void setIdade(int idade) {
        this.idade = idade;
    }       
}

//b)
public class CadastroDePessoas{
    public static void main(String args[]){
        Pessoa pessoa1 = new Pessoa("Jõao");
        Pessoa pessoa2 = new Pessoa("Lucas", 13, "8823-1033");
       
        pessoa1.setIdade(pessoa2.getIdade());
        pessoa1.setTelefone("8823-9029");
        pessoa2.setIdade(15);
       
        System.out.println("exibindo pessoas:\n" + "Nome: " + pessoa1.getNome()
        + "\nIdade: " + pessoa1.getIdade() + "\nTelefone: " + pessoa1.getTelefone());
       
        System.out.println("\nexibindo pessoas:\n" + "Nome: " + pessoa2.getNome()
        + "\nIdade: " + pessoa2.getIdade() + "\nTelefone: " + pessoa2.getTelefone());
    }

}
Postado por às Nenhum comentário:
Marcadores: , , ,

Crie uma classe chamada Empregado que possui três variáveis de instância (atributos)

Crie uma classe chamada Empregado que possui três variáveis de instância (atributos) – um primeiro nome (tipo String), um sobrenome (tipo String) e um salario mensal (tipo double). Forneça um construtor que inicializa as três variáveis de instância. Forneça também um método get e set para cada atributo da classe. Se o salario mensal não for positivo, não configura esse valor.

b) Crie uma classe EmpregadoTest com um método main que demonstra as capacidades da classe Empregado. Nessa classe, crie dois objetos Empregado e exiba o salario anual de cada (objeto) Empregado. Então dê para cada Empregado um aumento de 10% e exiba novamente os seus salarios anuais.

Feito:

Classe Empregado:

public class Empregado{
    private String nome, sobrenome;
    private double salario;
   
    Empregado(String nome, String sobrenome, double salario){
        this.nome=nome;
        this.sobrenome=sobrenome;
        this.salario=salario;
    }
   
    public String getNome() {
        return nome;
    }
    public void setNome(String nome) {
        this.nome = nome;
    }
   
    public String getSobrenome() {
        return sobrenome;
    }
    public void setSobrenome(String sobrenome) {
        this.sobrenome = sobrenome;
    }
   
    public double getSalario() {
        return salario;
    }
    public void setSalario(double salario) {
        if(salario>0){
        this.salario = salario;}
        else{System.out.println("Salário negativo, não configurado!");}
    }
}

//b)
public class EmpregadoTest{
    public static void main(String args[]){
        Empregado empregado1 = new Empregado("Junior", "Lacerda", 1500.500);
        Empregado empregado2 = new Empregado("Luiz", "Carvalho", 45000.000);
       
    System.out.println("Empregado 1: " + empregado1.getNome() + " " +
            empregado1.getSobrenome() +"\nsalario: "+ empregado1.getSalario());
 
    System.out.println("Empregado 1: " + empregado2.getNome() + " " +
            empregado2.getSobrenome() +"\nsalario: "+ empregado2.getSalario()); 
  
    empregado1.setSalario(empregado1.getSalario() + (empregado1.getSalario() * .10));
    empregado2.setSalario(empregado2.getSalario() + (empregado2.getSalario() * .10));
       
    System.out.println("\nCom acrécimo 10%: \n"
            + "Empregado 1: " + empregado1.getNome() + " " +
            empregado1.getSobrenome() +"\nsalario: "+ empregado1.getSalario());
 
    System.out.println("Empregado 1: " + empregado2.getNome() + " " +
            empregado2.getSobrenome() +"\nsalario: "+ empregado2.getSalario());
    }

}
Postado por às Nenhum comentário:
Marcadores: , , ,

Crie uma classe chamada Invoice para que uma loja de suprimentos de informática possa utilizá-la para representar uma fatura de um item vendido na loja.

Uma Invoice (fatura) deve incluir quatro partes de informações como variáveis de instância (atributos) – o numero (do tipo String), a descricao (do tipo String), a quantidade comprada de um item (tipo int) e o preco do item (do tipo double). Sua classe deve conter um construtor que inicializa as quatro variáveis de instância. Forneça um método get e set para cada atributo da classe. Além disso, forneça um método getInvoiceAmount que calcula o valor da fatura (isto é, multiplica a quantidade pelo preço por item). Se a quantidade não for positiva, ela deve ser configurada como 0 (zero). Se o preço por item não for positivo, ele deve ser configurado como 0.0.

b) Crie uma classe InvoiceTest, contendo um método main, que cria alguns objetos da classe Invoice e testa as capacidades da classe Invoice.

Feito:

a) Implementação classe Invoice

public class Invoice{
    private int numero, quantidade;
    private String descricao;
    private double preco;
   
    Invoice(){}
    Invoice(int numero, int quantidade, String descricao, double preco){
        this.numero=numero;
        this.quantidade=quantidade;
        this.descricao=descricao;
        this.preco=preco;
    }
   
    public void setNumero(int numero){
        this.numero=numero;
    }
    public void setQuantidade(int quantidade){
        this.quantidade=quantidade;
    }
    public void setDescricao(String descricao){
        this.descricao=descricao;
    }
    public void setPreco(double preco){
        this.preco=preco;
    }
   
    public int getNumero(){
        return numero;
    }
    public int getQuantidade(){
        return quantidade;
    }
    public String getDescricao(){
        return descricao;
    }   
    public double getPreco(){
        return preco;
    }

    public double getInvoiceAmount(){
        double amount = preco*quantidade;
        if(quantidade<0){ this.quantidade=0; }
        if(preco<0){this.preco=0.0;}
        return amount;
    }
}

//b)
import java.util.Scanner;

public class InvoiceTest{
    public static void main(String args[]){
        Scanner input = new Scanner(System.in);
       
        System.out.println("Quantos produtos deseja colocar na fatura?");
        int numeroDeProdutos=input.nextInt();
        Invoice produtos[] = new Invoice[numeroDeProdutos];
        double total = 0;
       
        for(int i=0;i<produtos.length;i++){
            produtos[i] = new Invoice();
            produtos[i].setNumero(i+1);
            System.out.println("Produto: " + (i+1));
            System.out.println("Insira um descrição: ");
            String descricao = input.next();
            produtos[i].setDescricao(descricao);
            System.out.println("Insira o preço: ");
            produtos[i].setPreco(input.nextDouble());
            System.out.println("Insira a quantidade: ");
            produtos[i].setQuantidade(input.nextInt());
            total+=produtos[i].getInvoiceAmount();
        }
       
        for(Invoice element:produtos){
            System.out.println("Produto de numero: " + element.getNumero());
            System.out.println("Descrição: " + element.getDescricao());
            System.out.println("Quantidade: " + element.getQuantidade());
            System.out.println("Preço: " + element.getPreco() + "\n");
        }
       
        System.out.println("Total da fatura: " + total);
    }
}
Postado por às 2 comentários:
Marcadores: , , ,

Crie uma classe chamada Data para representar uma datas.

Essa classe deve conter três atributos: o dia, o mês, e o ano. Considere também que a classe Data contém:

  • Um construtor que inicializa os três atributos e verifica a validade dos valores fornecidos;
  • Um método set() um get() para cada atributo;
  • Um método toString() que retorna uma representação da data como uma String. Considere, nesse caso, que a data deve ser formatada mostrando o dia, o mês e o ano separados por barra (/).
  • Um método avancarDia() que para avançar uma data para o dia seguinte.

b) Crie uma classe DataTest, com um método main, que cria alguns objetos da classe Data e utiliza as suas operações (métodos).

Feito:

a) Implementação classe Data:


public class Data{

    private int dia, mes, ano;

   

    public Data(int dia, int mes, int ano){

        this.dia = dia;
        this.mes = mes;
        this.ano = ano;
    }
   
    public void setDia(int dia){
        this.dia = dia;
    }
    public void setMes(int mes){
        this.mes = mes;
    }
    public void setAno(int ano){
        this.ano = ano;
    }
   
    public int getDia(){
        return dia;
    }
    public int getMes(){
        return mes;
    }
    public int getAno(){
        return ano;
    }
   
    public String toString(){
        return getDia() + "/" + getMes() + "/" + getAno();
    }
   
    public void avancarDia(){
        dia++;
        if(dia == 31){dia = 1; mes++;}
        if(mes == 13){mes = 1; ano++;}
    }
}


b)
import java.util.Scanner;

public class DataTest{
    public static void main(String args[]){
        Scanner input = new Scanner(System.in);
        Data data = new Data(01, 01, 2000);
            data.setDia(input.nextInt());
            data.setMes(input.nextInt());
            data.setAno(input.nextInt());
       
        System.out.println(data.toString());
        data.avancarDia();
        System.out.println("Próximo dia: " + data.toString());
       
    }
}
Postado por às Um comentário:
Marcadores: , , ,

Classe, Objetos e Construtores


1) O que são classes e objetos numa linguagem de programação orientada a objetos? Explique a diferença entre os dois.
Objetos são abstrações de objetos reais existentes, ou seja, a tentativa de representar um objeto do mundo real, no mundo virtual. A classe é o molde, ou a "planta" de construção de cada objeto.
2)Para que serve um construtor e quando e como ele pode ser utilizado?
Construtores servem para inicializar o objeto e devem ser invocados quando se desejar criar um objeto. Ele também pode ser pré-programado, para que se inicialize um objeto com atributos desejados.


3) Qual é o propósito da palavra reservada new? Explique o que acontece quando você a utiliza.
 A palavra reservada new tem o propósito de invocar o construtor para a inicia lização do objeto. Quando se utiliza new, se realizaram três tarefas:
  • Alocação de memória para o objeto;
  • Inicialização dos atributos com seus devidos valores atribuidos na classe, ou valores default;
  • O método construtor é chamado.



Postado por às Nenhum comentário:
Marcadores: , , ,
Assinar: Comentários (Atom)