TRABALHO - ALGORITIMX UNITED

TRABALHO FINAL

     Esse projeto tem como objetivo exemplificar o funcionamento de sensores infravermelhos, e demonstrar a sua utilidade em diversas situações cotidianas. No vídeo abaixo simulamos um dispositivo que recebe um sinal infravermelho e realiza um comando através deste. No caso, acender um LED.

Componentes:

- Resistor 1K ohm

- 7 jumpers

- 1 LED

- Módulo IR Receiver

- Protoboard

- Arduino UNO 

CÓDIGO:

#include <IRremote.h>

int pinoReceptor = 11;

int pinoLED = 9;

int estadoLED = LOW;

IRrecv receptor(pinoReceptor);

decode_results resultado;

void setup()

{

  Serial.begin(9600);

  pinMode(pinoLED, OUTPUT);

  receptor.enableIRIn();

}

void loop() {

  if (receptor.decode(&resultado)) 

  {

    guardarCodigo(&resultado);

    if(estadoLED == LOW)

    {

      estadoLED = HIGH;

      digitalWrite(pinoLED, estadoLED);

      Serial.println("Acendendo o LED");

    }

    else

    {

      estadoLED = LOW;

      digitalWrite(pinoLED, estadoLED);

      Serial.println("Apagando o LED");

    }

       

    receptor.resume();

  }

  delay(1000);

}

INTEGRANTES DO GRUPO: 

 

Arthur Napoleão

Artur Dias

Henrick Bartolo

Matheus Rocha

Definindo destino de caixas a partir de seu tamanho

Grupo Algoolatras

Nesse projeto decidimos criar um sistema que seria de grande utilidade em agencias do correio e em grandes transportadoras. Se trata de um sistema que identifica e separa caixas a partir de seu tamanho.

Para Montar utilizamos:

● 3 led’s de cores diferentes

● 1 Protoboard

● 1 Arduino Uno

● 1 Sensor ultrassônico HC-SR04

● Fios jumpers

● Caixas de diferentes tamanhos

Em resumo no nosso projeto os Leds representam o destino que cada caixa deve ter, o Led Vermelho acenderá caso a caixa tenha mais de 20 cm, o amarelo caso a caixa tenha entre 10 e 20 cm e o Led verde será acionado se a caixa tiver tamanho inferior a 10 cm.

Abaixo o codigo que utilizamos no arduino.

#include <Ultrasonic.h>

//Trigger no pino 6 - e Echo no pino 7

Ultrasonic ultrasonic(6,7);

//Declarando as constantes referentes aos pinos digitais.

const int ledVerde = 13;

const int ledAmarelo = 12;

const int ledVermelho = 11;

long microsec = 0;

float distanciaCM = 0;

void setup() {

  Serial.begin(9600);

   

  //Definindo pinos digitais

  pinMode(ledVerde,OUTPUT); //13 como de saída.

  pinMode(ledAmarelo,OUTPUT); //12 como de saída.

  pinMode(ledVermelho,OUTPUT); //11 como de saída.

}

void loop() { 

  microsec = ultrasonic.timing();

  /*Convertendo a distância em CM*/

  distanciaCM = ultrasonic.convert(microsec, Ultrasonic::CM);

  ledDistancia();

  Serial.print(distanciaCM);

  Serial.println(" cm");

  delay(1000);

}

void ledDistancia() {

   

  //Apagando todos os leds

  digitalWrite(ledVerde,LOW); 

  digitalWrite(ledAmarelo,LOW);

  digitalWrite(ledVermelho,LOW);

   

  //Acendendo o led correspondente ao tamanho da caixa

  if (distanciaCM > 20 and distanciaCM < 30) {

    digitalWrite(ledVerde,HIGH); 

  }

   

  if (distanciaCM <=20 and distanciaCM >= 10) {

    digitalWrite(ledAmarelo,HIGH);

  }

   

  if (distanciaCM < 10) {

    digitalWrite(ledVermelho,HIGH);

  }

}

Vídeo da execução do projeto:

Projeto final (MECHANIACS)

Simulação de um sensor de estacionamento utilizando Arduino

  Elementos que compõem o projeto

• Arduino UNO;
• Protoboard;
• Sensor HC-SR04;
• Um LED vermelho;
• Um LED amarelo;
• Um LED verde;
• Fios jumper

  Código

  

  Funcionamento

     Os três LEDs indicam a que distância determinado objeto se encontra do sensor ultrassônico. 

LED verde: Indica que o objeto está numa distância superior à 20cm.

LED amarelo: Indica que o objeto está numa distância entre 20 e 10cm.

LED vermelho: Indica que o objeto está numa distância de menos de 10cm.

   

     Além disso, incorporamos um alerta sonoro ao projeto por meio do buzzer, alterando o valor do delay para cada intervalo de distância.

Trabalho Final - Alarme Focalizado com Arduíno

Grupo: Avalon 

Este projeto consiste na criação de um alarme com um Arduino. Neste projeto nos determinando uma senha que inicializa o programa, um led verde que sinaliza o recebimento de informações, o sensor de distância possui um alcance de 80cm e um led vermelho para brilhar de acordo com a distância. Quando algo entra em seu alcance ele emite um sinal sonoro e e um sinal luminoso de um led vermelho sinalizando a existência de algum objeto.

 

A finalidade do alarme é sua utilização em sistemas de segurança de domicílios, permitindo um controle de acesso em determinado local, sendo colocando em pontos-chaves da residência, como janelas, portas e etc.

Componentes usados:

Um Arduíno;
Um alto-falante;

Um sensor de distância;

Um led verde;

Um led vermelho;

Um controle e um receptor de sinal infravermelho.

Tutorial de Utilização:

Ao iniciar pela primeira vez o usuário deve clicar um botão de configuração para alterar a senha posteriormente, após isso, digitar uma senha de 4 dígitos. Funciona com qualquer controle e o Led verde piscando significa que o usuário já pode digitar. Após a inclusão, o sistema irá verificar a área de utilização emitindo um sinal sonoro e piscando o Led verde. Pronto, o sistema já está em funcionamento, indicado pelo Led Verde aceso. Ao disparar, a senha deve ser digitada, e se estiver correta o sistema vai desarmar, nesse caso, a luz vermelha estará piscando.

Vídeo do Funcionamento:

Código do Programa:

 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <Arduino.h>
#include <NewTone.h> //  Biblioteca de som inclusa porque a função normal tune() conflita com IRremote
#include <IRremote.h>
#include <IRremoteInt.h>
#include <Ultrasonic.h>

#define pinoTrigger 4 // Pino do sensor ultrassonico
#define pinoEcho 5  // Pino do sensor ultrassonico
#define autoFalante 9
#define ledVermelho 10
#define ledVerde 12
#define pinoIR 3

int contador; // Contador utilizado diversas vezes em for
float confirmacao;
float proximidade = 0; // Proximidade mínima para disparo, regulada automaticamente
float bonof = 0;
float bmenu = 0;
float casa [4] = {0, 0, 0, 0}; // Strings de senha
float senha [4] = {0, 0, 0, 0}
unsigned long last = millis();

Ultrasonic ultrasonic(pinoTrigger, pinoEcho); // Definindo os pinos para a função ultrassonic
IRrecv irrecv(pinoIR);  //  Definindo os pinos para a função IRremote
decode_results results; // Para a função IRremote

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int confirmarSenha() {  // Função iniciada quando o sistema ativa o alarme
  for (contador = 0; contador <= 3; contador++) {
    while (casa[contador] == 0) {
      alarme();
      if (irrecv.decode(&results)) {
        noNewTone(autoFalante);
        NewTone(autoFalante, 1000);
        digitalWrite(ledVerde, HIGH);
        delay(30);
        noNewTone(autoFalante);
        digitalWrite(ledVerde, LOW);
        irrecv.resume();
        casa[contador] = results.value;
        Serial.println(casa[contador]);
        delay(500);
      }
    }
  }
  if (casa[0] == senha[0] && casa[1] == senha[1] && casa[2] == senha[2] && casa[3] == senha[3]) {
    casa[0] = casa[1] = casa[2] = casa[3] = 0;
    noNewTone(autoFalante);
    NewTone(autoFalante, 1000);
    delay(1000);
    noNewTone(autoFalante);
    delay(1200);
    return 1; // Senha OK
  } else {
    casa[0] = casa[1] = casa[2] = casa[3] = 0;
    NewTone(autoFalante, 500);
    delay(1000);
    noNewTone(autoFalante);
    delay(1200);
    return 0; // Senha Negada
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int disparo() { // Função que define a ativação do alarme
  if ((ultrasonic.convert(ultrasonic.timing(), Ultrasonic::CM))-1 < proximidade) {
    return 1;
  } else {
    return 0;
  }
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void configuracaoInicialDeDistancia(void) {
  for (contador = 600; contador >= 5; contador *= 0.8) {  // Apitar variando a velocidade
    NewTone(autoFalante, 1500);
    digitalWrite(ledVerde, HIGH);
    delay(50);
    noNewTone(autoFalante);
    digitalWrite(ledVerde, LOW);
    delay(contador);
  }

  for (contador = 1; contador <= 5; contador++) { // Pegar 5 amostras para a média
    proximidade += ((ultrasonic.convert(ultrasonic.timing(), Ultrasonic::CM)));
    delay(10);
  }
  proximidade = (abs(proximidade) + 1) / 5; // Impedir o 0 e tirar a média
  if (proximidade > 80) {
    proximidade = 80; // Limite onde não há muita variação
  } else {
    proximidade *= 0.8; // Taxa de 20% de variação
  }
  Serial.print("DISTANCIA DE ATIVAÇÃO DE: ");
  Serial.print(proximidade);
  Serial.println(" CM");
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void alarme(void) {  // Função que reproduz o som de alarme
  noNewTone(autoFalante);
  digitalWrite(ledVermelho, LOW);
  delay(50);
  NewTone(autoFalante, 1000);
  digitalWrite(ledVermelho, HIGH);
  delay(30);
  NewTone(autoFalante, 800);
  delay(50);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void onof_configuracao(void) {  // Função que liga, desliga e configura os botoes e senha do sistema
  if (irrecv.decode(&results)) {
    irrecv.resume();
    if (results.value == bonof) {
      digitalWrite(ledVerde, LOW);
      digitalWrite(ledVermelho, HIGH);
      Serial.println("DESATIVADO!");
      delay(5000);
      while (confirmacao != bonof) {
        if (irrecv.decode(&results)) {
          irrecv.resume();
          confirmacao = results.value;
          Serial.println(results.value);
        }
        delay(1000);
      }
      digitalWrite(ledVermelho, LOW);
      digitalWrite(ledVerde, HIGH);
      confirmacao = 0;
      delay(5000);
      Serial.println("ATIVADO!");


    }

    if (results.value == bmenu) {
      Serial.println("CONFIRMACAO DE SENHA!");
      digitalWrite(ledVerde, LOW);
      digitalWrite(ledVermelho, LOW);
      delay(2000);
      digitalWrite(ledVerde, HIGH);
      digitalWrite(ledVermelho, HIGH);
      delay(200);
      digitalWrite(ledVerde, LOW);
      digitalWrite(ledVermelho, LOW);
      delay(2000);

      for (contador = 0; contador <= 3; contador++) {
        while (casa[contador] == 0) {
          if (irrecv.decode(&results)) {
            noNewTone(autoFalante);
            NewTone(autoFalante, 1000);
            digitalWrite(ledVerde, HIGH);
            delay(30);
            noNewTone(autoFalante);
            digitalWrite(ledVerde, LOW);
            irrecv.resume();
            casa[contador] = results.value;
            Serial.println(casa[contador]);
            delay(500);
          }
          delay(500);
        }
      }

      if (casa[0] == senha[0] && casa[1] == senha[1] && casa[2] == senha[2] && casa[3] == senha[3]) {
        casa[0] = casa[1] = casa[2] = casa[3] = 0;
        delay(500);
        noNewTone(autoFalante);
        NewTone(autoFalante, 1000);
        delay(1000);
        noNewTone(autoFalante);
        Serial.println("CONFIGURACAO INICIADA!");
        confirmacao = 0;
        while (confirmacao == 0) {
          if (irrecv.decode(&results)) {
            noNewTone(autoFalante);
            NewTone(autoFalante, 1000);
            digitalWrite(ledVerde, HIGH);
            delay(30);
            noNewTone(autoFalante);
            digitalWrite(ledVerde, LOW);
            irrecv.resume();
            confirmacao = results.value;
            bonof = results.value;
            Serial.println(bonof);
            delay(1200);
          }
          delay(500);
        }
        confirmacao = 0;
        for (contador = 0; contador <= 3; contador++) {
          while (confirmacao == 0) {
            if (irrecv.decode(&results)) {
              noNewTone(autoFalante);
              NewTone(autoFalante, 1000);
              digitalWrite(ledVerde, HIGH);
              delay(30);
              noNewTone(autoFalante);
              digitalWrite(ledVerde, LOW);
              irrecv.resume();
              confirmacao = results.value;
              senha[contador] = results.value;
              Serial.println(senha[contador]);
              delay(1200);
            }
            delay(500);
          }
          confirmacao = 0;
        }
        digitalWrite(ledVerde, HIGH);
      } else {
        casa[0] = casa[1] = casa[2] = casa[3] = 0;
        NewTone(autoFalante, 500);
        delay(1000);
        noNewTone(autoFalante);
        delay(1000);
        digitalWrite(ledVerde, HIGH);
        delay(1200);
      }
    }
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  Serial.begin(9600);
  pinMode(8, OUTPUT);
  pinMode(ledVerde, OUTPUT);
  pinMode(ledVermelho, OUTPUT);
  irrecv.enableIRIn();

  while (bmenu == 0) {  // Configura o botão menu antes de iniciar o sensoriamento
    digitalWrite(ledVerde, HIGH);
    delay(500);
    digitalWrite(ledVerde, LOW);
    if (irrecv.decode(&results)) {
      noNewTone(autoFalante);
      NewTone(autoFalante, 1000);
      digitalWrite(ledVerde, HIGH);
      delay(30);
      noNewTone(autoFalante);
      digitalWrite(ledVerde, LOW);
      irrecv.resume();
      bmenu = results.value;
      Serial.println(bmenu);
      delay(1500);
    }
    delay(500);
  }

  for (contador = 0; contador <= 3; contador++) { // Configura a senha antes de iniciar o sensoriamento
    while (senha[contador] == 0) {
      digitalWrite(ledVerde, HIGH);
      delay(500);
      digitalWrite(ledVerde, LOW);
      if (irrecv.decode(&results)) {
        noNewTone(autoFalante);
        NewTone(autoFalante, 1000);
        digitalWrite(ledVerde, HIGH);
        delay(30);
        noNewTone(autoFalante);
        digitalWrite(ledVerde, LOW);
        irrecv.resume();
        senha[contador] = results.value;
        Serial.println(senha[contador]);
        delay(1500);
      }
      delay(500);
    }
  }
  configuracaoInicialDeDistancia(); // Onde apita para determinar a distancia de disparo
  digitalWrite(ledVerde, HIGH); // Simboliza a operatividade do sistema
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop() { // Aqui o sistema entra em operação
  onof_configuracao();
  if (disparo() == 1) {
    Serial.println("DISPARADO!");
    digitalWrite(ledVermelho, LOW);
    digitalWrite(ledVerde, LOW);
    while (confirmarSenha() == 0) {  }
    Serial.println("DESTRAVADO!");
    digitalWrite(ledVermelho, LOW);
    digitalWrite(ledVerde, HIGH);
  } else {
    noNewTone(autoFalante);
    delay(250);
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

ALGORITMX UNITED - PROJETO 2

Componentes utilizados no projeto:

- 3 Leds, 1 amarelo, 1 vermelho e 1 verde;

- 1 Protoboard;

- 1 NTC;

- 1 Motor DC 5 Volts;

- 1 Transistor TIP 120;

- 1 Diodo 1N4001;

-  Muitos fios jumpers;

- 1 Arduino UNO;

- 4 Resistores de 1k;

- 1 Resistor de 4.7K

Código utilizado no projeto.

Quando o NTC registra 21º C ou menos, o led verde acende e os demais apagam e o motor funciona com mais intensidade. Entre 22ºC e 23ºC, o led amarelo acende e os demais apagam e o motor liga. Acima de 23ºC o led vermelho acende e os demais desligam e o motor desliga.

Arthur Dias, Arthur Napoleão, Henrick Bartolo, Matheus Rocha.

Projeto 2 - Mechmaniacs

Projeto

Elaborar um circuito que faça a rotação do motor DC variar de acordo com a temperatura medida pelo sensor NTC.

Componentes Utilizados

• Protoboard
• Arduino Uno
• Motor DC 6V
• Diodo 1N4001
• Resistor 1kΩ
• Transistor TIP120
• 1 NTC
• Resistor 10kΩ
• 1 led vermelho
• 1 led verde
• 1 led amarelo
• 3 resistores 470Ω
• Jumpers

Representação do circuito no Autodesk

Código desenvolvido no software Arduino IDE

Temperaturas mais baixas ou iguais a 24ºC:

Led vermelho acende, valorPWM do motor é igual a 100 (velocidade de rotação baixa).

Temperaturas superiores a 24ºC e menores ou igual a 26ºC:

Led amarelo acende, valorPWM do motor é igual a 150 (velocidade de rotação média).

Temperaturas superiores a 26°C:

Led verde acende, valorPWM do motor é igual a 200 (velocidade de rotação alta).

Grupo Avalon 

 Projeto Módulo II: "Fazer o controle da rotação de um motor CC de acordo com a temperatura ambiente". 

 No projeto elaborado, a partir da elaboração de um código e um circuito no arduino, o grupo desenvolveu um sistema que a partir da temperatura determinava a rotação do motor CC e o acendimento ou não de três leds.
O material utilizado foi:

Leds difusos (verde, amarelo e vermellho);

1 NTC;

 Diodo 1N4001;

Transistor TIP120;

Motor DC 6V;

Resistores e fios jumper.


 Em uma temperatura inferior a 24 graus Celsius, o led verde ficava acesso e o motor desligado.
 Em uma temperatura entre 24 a 28 graus Celseius, o led amarelo ligava , o verde desligava e o motor iniciava a rotação.
 Em uma temperatura acima de 28 graus Celsius, o led vermelho ligava, o amarelo desligava e o motor rotacionava mais rápido.

ALGOÓLATRAS - Projeto 2

                              Projeto 2

O projeto 2 consiste na elaboração do controle da rotação de um motor fazendo o uso da temperatura externa do ambiente.

Componentes

- 3 Led amarelo, vermelho e verde;

- 1 Protoboard;

- 1 NTC;

- 1 Motor DC 5 Volts;

- 1 Transistor TIP 120;

- 1 Diodo 1N4001;

- Fios jumpers;

- 1 Arduino UNO;

- 4 Resistores de 1k;

- 1 Resistor de 4.7K;

Agora iremos mostrar o código do funcionamento do sistema de acionamento do motor medido pela temperatura

                                                    

Link do vídeo:  https://youtu.be/x747w7jolTY


O motor gira de acordo com a temperatura do ambiente. Quando o Led verde está ligado significa que a temperatura do ambiente se encontra maior que 22° C, e o motor vai rotacionar em uma frequência de 50 rpm. Já se o Led amarelo estiver ligado significa que a temperatura ambiente se encontra entre 21°C e 22°C, o motor não vai rotacionar. Caso seja o Led vermelho a estar ligado significa que a temperatura ambiente se encontra abaixo de 21°C, e o motor estará em uma rotação de 100 rpm.

*A biblioteca utilizada foi <Thermistor.h>: Essa biblioteca nos possibilitou fazer o cálculo da conversão do valor lido pelo NTC para °C.   

Comandos de Seleção e Comandos de Repetição

Comandos de Seleção

Comando IF

• Formato Geral:

 if (condição) declaração;

No comando if, a expressão da condição será avaliada. Se for zero (falsa), a declaração não será executada. Se for diferente de zero (verdadeira), a declaração será executada. A declaração pode ser um bloco de código ou apenas um comando. É a maneira mais simples de representar uma tomada e decisão do tipo "se isto, então aquilo".

• Formato if-else:

if (condição) declaração_1;
else declaração_2;

O comando else é um complemento do comando if. Fazendo uso dele, agora podemos executar uma declaração caso a condição seja falsa e uma outra diferente caso seja verdadeira. No entanto, é importante salientar que usando a estrutura if-else, sempre uma das duas declarações será executada. Nunca as duas, ou nenhuma.

• Formato if-else-if:

if (condição_1) declaração_1;
else if (condição_2) declaração_2;
else if (condição_3) declaração_3;
.
.
.
else if (condição_n) declaração_n;
else declaração_final;

Nessa estrutura, o programa começa a testar as condições começando pela 1 e continua a testá-las até que ache uma expressão cujo resultado seja verdadeiro. Quando a encontra, executa a declaração correspondente. Apenas uma declaração será executada, ou seja, a primeira que for verdadeira. Caso todas sejam falsas, será executada a declaração final (opcional).

Comando SWITCH

• Formato Geral:

switch (variável)
{
case valor_1:
declaração_1;
break;
case valor_2:
declaração_2;
break;
.
.
.
case valor_n:
declaração_n;
break;
default:
declaração_final;
}

O comando switch, assim como o comando if, é usado para tomada de decisão. No entanto, para assegurar um código elegante, enxuto e de fácil entendimento, ele pode ser usado como uma espécie de if-else-if, com a diferença de não aceitar expressões. Apenas constantes. O comando testa a variável e executa a declaração correspondente ao valor atual dessa variável. Caso o valor não seja igual a nenhuma das constantes, será executada a declaração final (opcional).

Comandos de Repetição

Comando FOR

• Formato Geral:

for (inicialização;condição;incremento) declaração;

O comando for é utilizado para repetir um comando, ou bloco de comandos, repetidas vezes e de maneira controlada. Ele testa a condição, executa a declaração, incrementa a variável, e testa novamente. Ou seja, enquanto a condição for verdadeira será executada a declaração. Podemos utilizar o comando omitindo informações para termos efeitos diferentes: Se omitirmos a condição, o programa já não para mais de executar a declaração caso a condição seja falsa, gerando um loop infinito. Da mesma maneira, omitindo a declaração podemos fazer o programa "esperar" uma quantidade de tempo antes de prosseguir para a próxima linha de código.

Comando WHILE

• Formato Geral:

while (condição) declaração;

O comando testa a condição, e caso verdadeira, é executada a declaração. Em seguida ele verifica a condição novamente, e assim por diante. É uma versão um pouco diferente do comando for. For parece ser mais apropriado quando o número de iterações do loop é conhecido antecipadamente. Por outro lado, em situações em que o número de repetições depende de outras variáveis, tornando difícil defini-lo, usa-se, preferencialmente while.

Comando DO-WHILE

• Formato Geral:

do
{
declaração;
}
while (condição);

O comando do-while executa a declaração. testa a condição e, caso verdadeira, volta para a declaração. A principal diferença para for e while é que do-while garante que a declaração seja executada pelo menos uma vez.

COMANDOS DE SELEÇÃO E REPETIÇÃO

Comandos de Seleção

    If – Este comando é usado para executar um comando apenas se a condição descrita nele for verdadeira.

            If(condição) declaração;

            {comandos}

   Else – É utilizado após o if e executa um comando se a condição do if não for verdadeira.

            If(condição) declaração;

            {comandos}

            Else {comandos}

   Os comandos if e else podem ser utilizados dentro das condições de outros ifs e elses formando estruturas conhecidas como else-if e if-else, que analisam mais condições dependendo dos resultados das anteriores e executando seus respectivos comandos com base em suas próprias condições.

           

  Switch – Testa uma variável e executa um comando dependendo do seu valor. Os valores são comparados com os valores que acompanham os cases.

           

                    Switch (variável) declaração;

                        case valor1: declaração; break;

                        case valor2: declaração; break;

                        case valor3: declaração; break;

(opcional)   default: declaração; break;

  O default é acionado quando o valor da variável não é representado pelos valores testados nos cases. O break para o switch e pula para o próximo comando (pode ser usado em outros comandos além do switch).

Comandos de Repetição

  While – Testa uma variável ou expressão e executa um comando enquanto for verdadeira.

            While (variável) {comandos}

   For – inicializa uma variável, testa a condição, incrementa ou decrementa e executa um comando enquanto a condição for verdadeira.

for(variável; condição; operação)

{comando}

  Do while – Executa um comando e testa a condição, se verdadeira executa o comando novamente e continua esse processo até que a condição seja falsa.

            do

            {comandos}

            while(condição);

Grupo: Algoritmx United: Arthur Dias, Arthur Napoleão, Henrick Bartolo e Matheus Rocha.