Mostrando postagens com marcador Arduino. Mostrar todas as postagens
Mostrando postagens com marcador Arduino. Mostrar todas as postagens

Relatório técnico - Batalha de Robôs

Nesta postagem vou tentar orienta-los sobre como elaborar o relatório do robô desenvolvido na disciplina de introdução a IoT. Dentre as recomendações, a primeira e fundamental recomendação é:

 - Siga a formatação  do documento disponível aqui no blog. 
                                                   Clique aqui para acessar o documento

Após fazer o download do documento acima, vamos aos itens que não podem faltar no relatório/grupos:

 - Todos os robôs(grupos) devem ter um nome.

 - Todos os textos devem conter no minimo os seguintes itens:

- Sumario
- Índice de figura
- Índice de tabelas
- Lista de abreviações e siglas

- Introdução
    - Justificativa
    - Objetivos
- Revisão da literatura
    - Texto falando sobre robô moveis, importância e aplicações;
- Metodologia 
    - Mostrando todos os item usado no projeto (arduino, shield, bluetooth, aplicativos cel, etc);   
    -  Descrever e justificar cada item do projeto;
    - Apresentar circuitos;
    - Tabelas de utilização de pinos;
- O Robô 
    - Mostrar partes da montagem do robô (Fotos montagem e carro pronto);
- Conclusão
    - Lições aprendidas;
    - Resultado final;
- Referencias 
    - Artigos, livros e sites de onde as informações foram tiradas;
- Apêndice 
    - Tabela com preços do material usado;
    - Código usado no Arduíno;
    - problemas, dificuldades e soluções do projeto;


Não esquecer que:
     - Esse documento é um relatório, não fique com preguiça de escrever;
     - Não esqueça de colocar informações técnicas;
     - Toda figura e tabela tem legenda e deve ser referenciada no texto;
     - Trabalho sem conclusão não é trabalho;



Ainda ta com duvida, curta nossa pagina no facebook no link abaixo e poste sua duvida lá.


Comunicação Bluetooth - HC-06

Criado em 1994 pela Ericsson, o Bluetooth é uma especificação de rede sem fio (IEEE 802.15.1) utilizada para conectar dispositivos pessoais como telefones celulares, notebooks, computadores, dispositivos IoT, entre outros permitindo a troca de informações entre esses dispositivos através de uma frequência de rádio de curto alcance. Devido sua versatilidade, diversos shields de bluetooth foram desenvolvido onde podemos citar o NRF2401, os módulos ZIGBEE e o HC-06 que será usado em nossa experiência. Na figura 1 podemos ver uma foto do modulo HC-06.


Figura 1. Modulo Bluetooth HC-06.
Para ligar o bluetooth ao Arduíno é bem simples, para isso basta polarizar o dispositivo ligando VCC e GND aos pinos de 5V e GND do Arduíno e o RX e TX aos pinos 0 e 1 conforme indicado na figura 2.
Figura 2. Polarização e conexão RX/TX do Modulo HC-06.

O desenvolvimento do código é bem simples, basta usar a biblioteca SoftwareSerial.h que permite que o chip Atmega receba comunicação serial mesmo enquanto trabalha em outras tarefas, desde que haja espaço no buffer serial de 64 bytes. Para maiores informações sobre essa biblioteca, clique aqui.

Os comando utilizados em nosso experimentos serão:

SoftwareSerial bluetooth(rxPin, txPin) -  O SoftwareSerial é usado para criar uma instância de um objeto SoftwareSerial, cujo nome (bluetooth) você precisa fornecer. Os parâmetros rxPin, txPin são referentes aos pinos utilizados no Arduíno para realizar a comunicação RX/TX.

bluetooth.begin(BAUD) - Define a velocidade (taxa de transmissão) para a comunicação serial, onde BAUD é o valor da taxa (para saber mais sobre comunicação serial, cilque aqui).

bluetooth.println("TEXTO") -  Imprime dados no pino de transmissão da porta serial do software. Funciona da mesma forma que a função Serial.print ().

bluetooth.read() -  Retorna um caractere que foi recebido no pino RX da porta serial do software. 

Hardware e software devidamente configurado, para realizar nossos testes, podemos fazer o download no celular do Aplicativo Bluetooth terminal. Após baixar o aplicativo, basta realizar um scan para localizar o HC-06 e parear os dispositivos. Caso o celular solicite uma senha, digite 1234.

Com base no circuito da figura 2 e nos comandos descritos acima, o programa abaixo irá acender um LED na porta 13 quando a letra 'H' for digitada e apaga-lo quando for digitado a letra 'L'.

#include <SoftwareSerial.h>// Incluir biblioteeca Software Serial para habilitar bluetooth
SoftwareSerial bluetooth(1, 0); //indicação das entradas onde TX, RX serão ligadas
int RXBLUE;

void setup() 
{
  //Habilitando leds na porta 13
  pinMode(13, OUTPUT);

  //Inicializando  software serial - Bluetooth
  bluetooth.begin(9600);
  bluetooth.println("iniciando bluetooth");
  bluetooth.println("Digite H para ligar o LED");
  bluetooth.println("Digite L para desligar o LED");
}

void loop() {
  //Checa se bluetoohth esta conectado
   if (bluetooth.available()>0)
  {
    RXBLUE = bluetooth.read();
    bluetooth.println("Led ligado");
    if(RXBLUE == 'H')
    {
      digitalWrite(13, HIGH);
      bluetooth.println("Led ligado");

    }
    if(RXBLUE == 'L')
    {
      digitalWrite(13, LOW);
      bluetooth.println("Led desligado");
    }
  }
}


Você poderá verificar a implementação do código/circuito acima clicando na imagem abaixo.

 Exclusão mutua com Arduíno




Não esqueça do like do video e de curtir nossa pagina no facebook no link abaixo:

Brincando com o Multi function Shield

O projeto Arduíno foi criado para prover facilidade no desenvolvimento de projetos microcontrolados e certamente um dos grandes responsáveis por essa facilidade é o shield.
Shields" é o nome dado às placas de expansão de hardware que encaixam na placa Arduíno principal.  Através dos Shields podemos adicionar novos elementos ao nosso projeto sem a necessidade de grandes conhecimentos em eletrônica. Os circuitos contidos nos diversos shields  existente contém uma eletrônica que adiciona funções que a placa principal não possui. Nessa postagem iremos apresentar o Multi function Shield da figura 1.
Figura 1. Multi function Shield  

No caso do  Multi function Shield, temos os seguintes componentes instalados:

UnitPIN #
Buzzer (autofalante/beeper)3 (digital On/Off)
4 LEDs10, 11, 12, 13
3 botões + reset buttonA1, A2, A3
Potenciômetro (10 kOhm)A0
4 Displays de 7-sementos e driven 74HC595Latch 4, Clock 7, Data 8
Socket para sensor IR (controle remoto)2
Socket para sensor LM35 ou DS18B20A4
Pinos para BluethoothGND, +5v, 0, 1 (rx/tx)
Pinos livres (pwm)5, 6, 9, A5



Buzzer 

O primeiro componente que iremos testar no shield é o buzzer. Usado para emitir sons de alerta, o buzzer pode ser configurado para tocar melodias idem ao video que pode ser acessado clicando no link abaixo:

Melodia com Arduino



Para testar o buzzer do  Multi function Shield  vamos utilizar o código abaixo:

int portSpeak(3);  //porta ligada no speaker

//melodia
int melodia[] = {660,660,660,510,660,770,380,510,380,320,440,480,450,430,380,660,760,860,700,760,660,520,580,480,510,380,320,440,480,450,430,380,660,760,860,700,760,660,520,580,480,500,760,720,680,620,650,380,430,500,430,500,570,500,760,720,680,620,650,1020,1020,1020,380,500,760,720,680,620,650,380,430,500,430,500,570,585,550,500,380,500,500,500,500,760,720,680,620,650,380,430,500,430,500,570,500,760,720,680,620,650,1020,1020,1020,380,500,760,720,680,620,650,380,430,500,430,500,570,585,550,500,380,500,500,500,500,500,500,500,580,660,500,430,380,500,500,500,500,580,660,870,760,500,500,500,500,580,660,500,430,380,660,660,660,510,660,770,380};

//duraçao de cada nota
int duracaodasnotas[] = {100,100,100,100,100,100,100,100,100,100,100,80,100,100,100,80,50,100,80,50,80,80,80,80,100,100,100,100,80,100,100,100,80,50,100,80,50,80,80,80,80,100,100,100,100,150,150,100,100,100,100,100,100,100,100,100,100,150,200,80,80,80,100,100,100,100,100,150,150,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,150,150,100,100,100,100,100,100,100,100,100,100,150,200,80,80,80,100,100,100,100,100,150,150,100,100,100,100,100,100,100,100,100,100,100,100,100,60,80,60,80,80,80,80,80,80,60,80,60,80,80,80,80,80,60,80,60,80,80,80,80,80,80,100,100,100,100,100,100,100};

void setup() {
  //for para tocar as 156 notas começando no 0 ate 156 ++ incrementado
        for (int nota = 0; nota < 156; nota++) {

              int duracaodanota = duracaodasnotas[nota];
              tone(portSpeak, melodia[nota],duracaodanota);

  //pausa depois das notas
              int pausadepoisdasnotas[] ={150,300,300,100,300,550,575,450,400,500,300,330,150,300,200,200,150,300,150,350,300,150,150,500,450,400,500,300,330,150,300,200,200,150,300,150,350,300,150,150,500,300,100,150,150,300,300,150,150,300,150,100,220,300,100,150,150,300,300,300,150,300,300,300,100,150,150,300,300,150,150,300,150,100,420,450,420,360,300,300,150,300,300,100,150,150,300,300,150,150,300,150,100,220,300,100,150,150,300,300,300,150,300,300,300,100,150,150,300,300,150,150,300,150,100,420,450,420,360,300,300,150,300,150,300,350,150,350,150,300,150,600,150,300,350,150,150,550,325,600,150,300,350,150,350,150,300,150,600,150,300,300,100,300,550,575};
              delay(pausadepoisdasnotas[nota]);}

              noTone(portSpeak);
}

void loop() {

}

Leds

Conforme já mencionado, no  Multi function Shield  os leds estão ligados aos pinos 10, 11, 12 e 13 do Arduíno. No código abaixo iremos piscar todos os leds ao mesmo tempo. 
int led1 = 13;
int led2 = 12;
int led3 = 11;
int led4 = 10;
void setup()
{
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}
void loop() 
{
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);
  digitalWrite(led3, HIGH);
  digitalWrite(led4, HIGH);
  delay(1000);
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
 digitalWrite(led3, LOW);
 digitalWrite(led4, LOW);
 delay (1000);
}

Botões

Os botões no Multi function Shield foram implementados de maneira onde quando pressionado, a entrada do Arduíno que o botão estão ligado recebera o sinal HIGH. No programa abaixo temos um exemplo onde usamos dois botões para acender e apagar os leds do shield.
#define Bt1 A1  //Botão 1 do shield configurado no pino A1
#define Bt2 A2  //Botão 1 do shield configurado no pino A1
int led1 = 13;
int led2 = 12;
int led3 = 11;
int led4 = 10;
void setup()
{
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}
void loop() 
{
  if(!digitalRead(Bt1)) //se o valor de botão 1 for 0 liga leds
  {
    digitalWrite(led1, HIGH);
    digitalWrite(led2, HIGH);
    digitalWrite(led3, HIGH);
    digitalWrite(led4, HIGH); 
  }
  if(!digitalRead(Bt2)) //se o valor de botão 1 for 0 desliga leds
  {
    digitalWrite(led1, LOW);
    digitalWrite(led2, LOW);
    digitalWrite(led3, LOW);
    digitalWrite(led4, LOW);
  }
}

Potenciômetro 


Potenciômetro é resistor com resistência variável. Será utilizado para enviar um sinal analógico ao Arduíno. Na figura 2 temos alguns exemplos de potenciômetros.
Figura 2. Exemplos de potenciômetros.
Por permitir variar a resistência, segundo a lei de OHM teremos uma modulação da tensão, logo o potenciômetro deve ser ligado a porta analógica do Arduíno.  No caso do kit Multi function Shield  o potenciômetro está ligado a porta analógica A0. Abaixo segue como medir o valor na entrada A0 que será modulada pelo potenciometro e enviar o valor para a porta serial.
#define Pot1 0 
void setup() 

       Serial.begin(9600); 

void loop() 

    int PotValue;
    PotValue = analogRead(Pot1); 
    Serial.print("Potenciomentro: "); 
    Serial.println(PotValue); 
 }

Display de 7 segmentos

Displays de sete segmentos são usados em eletrônica para de exibir uma informação alfanumérica (binário, decimal ou hexadecimal). devido a simplicidade e fácil configuração  seu uso é muito popular.
Figura 3. Display de 7 segmentos - Facilidade para representar números. 
Como o próprio nome já diz, um display de sete segmentos é composto de sete elementos (LEDs), os quais podem ser ligados ou desligados individualmente. Na figura 4 podemos observar que no display de 7 segmentos temos um anodo comum e o catodo de cada LED receberá um nome (A, B, C,...), assim para formação dos dígitos, basta seguir a "tabela do decodificador" mostrada na figura 4.
Figura 4. Configuração do display de 7 segmentos.
O Multi function Shield  possui um registrador de descolamento onde os valores e o display que será utilizado é controlado por codificação em hexadecimal. Os código abaixo irá mostrar os numero 0 1 2 3 no display.

int LED[]= {13,12,11,10}; /* Configurações do registador de deslocamento */ #define LATCH_DIO 4 #define CLK_DIO 7 #define DATA_DIO 8 /* Mapa de Segmentos dos números de 0 to 9 */ const byte SEGMENT_MAP[] = {0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0X80,0X90}; /* Byte maps to select digit 1 to 4 */ const byte SEGMENT_SELECT[] = {0xF1,0xF2,0xF4,0xF8}; void setup () { /* Set DIO pins to outputs */ pinMode(LATCH_DIO,OUTPUT); pinMode(CLK_DIO,OUTPUT); pinMode(DATA_DIO,OUTPUT); } void loop() { /* O comando WriteNumberToSegment indicando qual numero deve ser escrito e o segmento */
WriteNumberToSegment(0 , 0);
WriteNumberToSegment(1 , 1);
WriteNumberToSegment(2 , 2);
WriteNumberToSegment(3 , 3);
}
 
/* Função que controlará os displays */
void WriteNumberToSegment(byte Segment, byte Value)
{
digitalWrite(LATCH_DIO,LOW);
shiftOut(DATA_DIO, CLK_DIO, MSBFIRST, SEGMENT_MAP[Value]);
shiftOut(DATA_DIO, CLK_DIO, MSBFIRST, SEGMENT_SELECT[Segment] );
digitalWrite(LATCH_DIO,HIGH);
}




Desafios:
Desafio 1 - Faça um programa que conte de 0 a 9 com intervalo de 1 segundo, uso estrutura de repetição FOR.
Desafio 2 - Receba uma centena via serial e exiba a centena no display
Não esqueça do like do video e de curtir nossa pagina no facebook no link abaixo:

Manipulação de EEPROM - parte 2

Conforme discutido em nossa postagem Manipulação de EEPROM, os dados são gravados em formato de Byte o que gera um problema porque em 1 Byte, só é possível armazenar  valor de 255 em decimal.

11111111 =  255

Quando precisamos guardar valores maiores que 255 é preciso fazer uma adaptação para que seja possível recuperar os valores armazenado. Para isso precisaremos de duas posições de memoria, onde iremos dividir o valor por 256 e armazenar o valor do Quociente numa posição da memória e o valor do resto em outra posição de memória. No exemplo abaixo, iremos armazenas o numero 72010.
Após realizar o calculo de 72010/256, iremos armazenar o valor 281 na primeira posição de memória e 74 na segunda posição de memoria. O programa abaixo mostra o codificação do caso apresentado.

#include <EEPROM.h>

void setup()
{
  Serial.begin(9600);
}

int Q;
int resto;

void loop()
{
  Serial.print("Gravando 72010 na memoria EEPROM : ");
  Q= 72010/256;
  resto = 72010%256;
  EEPROM.write(0, Q);
  Serial.printDado 1 : ");
  Serial.println(Q);
 
  EEPROM.write(1, resto);  // % operador para extrair o resto da divisão
  Serial.print("Dado 2 : ");
  Serial.println(resto);



Para realizar a leitura da memória, precisaremos realizar a operação inversa, onde precisaremos ler as duas posições de memoria onde os números foram gravados, recuperar os valores e aplicar a seguinte fórmula:

Valor original = (dado1 * 256) + dado2

Segue codificação do exemplo acima.


#include <EEPROM.h>

void setup()
{
  Serial.begin(9600);
}

int Q;
int resto;

void loop()
{
  Serial.println("\nLendo numero da memoria EEPROM... ");
 
  Q = EEPROM.read(0);// lendo valor do Quociente da divisão no endereço 0 da memória
  resto = EEPROM.read(1); // lendo valor do resto da divisão no endereço 1 da memória
 
 
  Serial.print("Valor = ");
  int x = (Q * 256) + resto;
  Serial.println(x);
}e


Pratique:

Exercício 1 - Faça que se comunique com o usuário através da USB e receba um numero via USB  e salve na memória EEPROM, como sabemos que a EEPROM tem um tempo de vida, voce deve criar controles para que a memória só seja acessada quando realmente houver um dado a ser gravado.


Não esqueça do like do video e de curtir nossa pagina no facebook no link abaixo:

Manipulação de EEPROM

Todos os modelos Arduíno (pelo menos os que eu conheço) possuem uma EEPROM (Electrically Erasable Programmable Read-Only Memory).  O modelo UNO possui uma memória de 1k Byte EEPROM que pode ser usada pelos programadores em aplicações onde valores aferidos por sensores ou outros dispositivos precisam ficar armazenadas de maneira não volátil e por longos períodos de tempo. Para facilitar a vida do programador, a  biblioteca EEPROM.h que oferece as seguintes funções como:

    - EEPROM.write()
    - EEPROM.read()
    - EEPROM.update()
    - EEPROM.length()
    - EEPROM.clear

EEPROM.write escreve um byte para um determinado endereço da EEPROM cuja a sintaxe é dada por:

EEPROM.write (endereço, valor);

onde:
      endereço:  local para onde escrever, a partir de 0 ( int )
      valor: o valor a escrever, de 0 a 255 ( byte )

Exemplo:

// neste exemplo iremos gravar os números de 0 a 255 nos endereços de 0 a 255.

#include <EEPROM.h>

void setup()
{
  for (int i = 0; i < 255; i++)
    EEPROM.write(i, i)
}

void loop()
{
}

Observe que a gravação dos dados foi realizada na função setup. Isso foi feito propositalmente pois a memória EEPROM tem uma vida útil especificada de aproximadamente 100.000 ciclos de gravação / exclusão, portanto, talvez seja necessário ter cuidado com a frequência com que você escreve nela, logo evite gravar e apagar a EEPROM dentro da função loop sem uma lógica que controle essas operações.

EEPROM.read  é responsável por ler um byte para um determinado endereço da EEPROM cuja a sintaxe é dada por:

EEPROM.read (endereço);

onde:
      endereço:  local para onde ler, os endereços começam em 0 ( int )


Exemplo:

/* exemplo tirado do site arduino.cc onde os valores de 0 a 512 serão lidos e apresentados na serial */
#include <EEPROM.h>

int a = 0;
int value;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  value = EEPROM.read(a);

  Serial.print(a);
  Serial.print("\t");
  Serial.print(value);
  Serial.println();

  a = a + 1;

  if (a == 512)
    a = 0;

  delay(500);
}

EEPROM.update escreve um byte para a EEPROM. O valor é escrito apenas se diferir do que já foi salvo no mesmo endereço. A sintaxe do update é dada por:

EEPROM.update(endereço, valor);

onde:
      endereço:  local para onde escrever, a partir de 0 ( int )
      valor: o valor a escrever, de 0 a 255 ( byte )

Exemplo:

//exemplo retirado de Arduino.cc
#include <EEPROM.h>

void setup()
{
  for (int i = 0; i < 255; i++) {
    // this performs as EEPROM.write(i, i)
    EEPROM.update(i, i);
  }
  for (int i = 0; i < 255; i++) {
    // write value "12" to cell 3 only the first time
    // will not write the cell the remaining 254 times
    EEPROM.update(3, 12);
  }
}

void loop()
{
}


EEPROM.length esta função devolve um valor contendo o número de células na EEPROM. Nem todos os dispositivos têm o mesmo tamanho de EEPROM, isso pode ser útil para escrever códigos portáveis ​​para diferentes Arduinos. Como não há passagem de paraetros, a sintaxe do comando é dada por:

EEPROM.length();

Exemplo:

/* exemplo tirado do site arduino.cc onde os valores de 0 a o final da memória não importando o tamanho da memória. Os valores lidos são mostrados apresentados na serial */

#include <EEPROM.h>

int a = 0;
int value;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  value = EEPROM.read(a);

  Serial.print(a);
  Serial.print("\t");
  Serial.print(value);
  Serial.println();

  a = a + 1;

  if (a == EEPROM.length())
    a = 0;

  delay(10);
}


Pratique:

Exercício 1 - Faça um programa que se comunique com o usuário através da USB e pergunte se ele quer gravar ou ler uma informação na EEPROM. Quando a opção for ler um dado, o usuário deve digitar o endereço da informação. Quando a opção for gravar um dado, o Arduino deve saber qual é a primeira posição livre da memória para realizar a gravação.

Exercício 2 - Como descrito na teoria acima, um endereço de memória possui só 1 byte que corresponde no máximo ao valor 255 em decimal. Faça um programa onde seja possível gravar e ler um valor maior que 255 na memória da EEPROM.


Para acessar um conteúdo extra sob gravação e leitura de EEPROM clique aqui.

Não esqueça do like do vídeo e de curtir nossa pagina no facebook no link abaixo:

Condição de Corrida - Resolvendo um problema de SO com Arduíno

Uma condição de corrida (Race condition) é uma falha num sistema ou processo, que pode ocorrer quando dois ou mais processo acessam um recurso compartilhado de maneira concorrente. Quando temos dois processos acessando um recurso compartilhado de maneira concorrente, o resultado final vai depender de qual processo executa o recurso primeiro. Conforme podemos visualizar no vídeo abaixo, a condição de corrida ocasiona um comportamento não-determinístico.


Para evitar o problema descrito no vídeo acima devemos definir as regiões críticas do processo e implementar uma forma de exclusão mútua. Com base no problema apresentado no vídeo, a figura 1 mostra um circuito onde o Led irá simular a região de exclusão mutua e os botões simularão dois processos que podem ligar e desligar o Led. Neste circuito, somente o botão que ligou o Led tem permissão para desligar o Led.
Figura 1. Circuito simulando Exclusão mútua usando Led e botões..
Resultado final da exclusão mutua pode ser vista acessando o Youtube clicando na imagem abaixo.

 Exclusão mutua com Arduíno

Para solucionar esse problema foi usado uma variável de bloqueio que controlará o acesso a região critica. Se quiser maiores informações, deixei uma mensagem aqui no blog.....


Não esqueça do like do video e de curtir nossa pagina no facebook no link abaixo:

Controle de motor CC com potenciômetro.

Nesta experiencia iremos variar a velocidade de um motor dc usando PWM (não sabe o que é PWM - clique aqui) . A modulação do PWM será feita por um potenciômetro.

Material necessário:

- Arduíno
- 4 Led's
- 4 resistores 330 OHM
- Potenciômetro 10 kOHM
- Motor DC

Na figura 1 temos a montagem do circuito utilizado na experiencia.
Figura 1. Circuito usado para controlar velocidade do motor atraves do potenciometro.

int potenciometro = 5;
int vPot = 0;
int vmotor=0;

void setup()
{
  pinMode(7,OUTPUT);
  pinMode(6,OUTPUT); 
  pinMode(5,OUTPUT); 
  pinMode(4,OUTPUT);
  pinMode(10, OUTPUT);

  Serial.begin(9600);
}

void loop()
{
 //Leitura do valor do potenciômetro
  vPot = analogRead(potenciometro);
 
  vmotor = map(vPot, 0, 1023, 0, 255); // mapeamento do potenciometro(0 a 1023) para PWM (0 a 255)
  analogWrite(10, vmotor); // velocidade do motor em PWM
  // Chama função controle_led que irá ligar os led's em função da velocidade do motor.
  controle_led();
}

void controle_led()
{

   //Rotina para ligar led
  if( vPot >=180)
  {
   digitalWrite(7, HIGH);
   if( vPot >=360)
   {
    digitalWrite(6, HIGH);
    if( vPot >=540)
    {
      digitalWrite(5, HIGH);
      if( vPot >=720)
      {
        digitalWrite(4, HIGH);
      }
    }
   } 
  }   
 
    if( vPot <180)
    {
    digitalWrite(7, LOW);
    }
   if( vPot <360)
   {
    digitalWrite(6, LOW);
   }
    if( vPot <540)
    {
      digitalWrite(5, LOW);
    }
      if( vPot <720)
      {
        digitalWrite(4, LOW);
      }
}


Você poderá verificar a implementação do código/circuito acima clicando na imagem abaixo.

 Exclusão mutua com Arduíno


Leitura complementar:

Entendendo PWM
- O que é a função MAP
- Controle de motor DC


Não esqueça do like do video e de curtir nossa pagina no facebook no link abaixo:

Trabalhando com Sensores de Infravermelho

Dentre todas as radiações que somos expostos diariamente, somente uma pequena porção (espectro visível) que se manifesta atraves da emissão de luz é possivel ser observada pelo olho humano. Na figura 1 um espectro eletromagnético é apresentado onde podemos observar que há varias outras radiações invisível com comprimento de onde especifico e bem conhecidos.

Figura 1.   Espectro eletromagnético - créditos Shutterstock.com 



Dentre as ondas eletromagneticas não visiveis, podemos citar o Infravermelho (IR) cujo nome significa "abaixo do vermelho" e seu comprimento de onda varia de 750 nm a 1mm.
Devido da facilidade de trabalhar com o infravermelho, nos anos 40 (2ª Guerra mundial) apareceram os primeiros controles remotos que usavam o infravermelho para enviar uma sequencia de pulsos para um receptor que interpretava esse sinal e executar alguma função, nesse casos especifico, o controle remoto detonava bombas a distancia. Até os dias de hoje o controle remoto trabalha da mesma maneira o que nos permite usa-lo para realizar algum tipo de automação.

Para realizar nosso projeto com controle remoto, você poderá comprar qualquer sensor de IR (por exemplo Hx1838) assim como qualquer controle remoto IR.......


Identificando cada botão do controle:

No principio de funcionamento do controle, cada botão corresponde um código específico, gerado por um microprocessador que fará o emissor IR piscar numa determinada sequencia binária. Quando essa sequencia pulsada chega ao receptor, o microcontrolador do receptor irá processar essa sequencia bits e realizar uma ação. 
Como você comprou qualquer controle e não conhece a codificação de cada botão, será preciso criar um circuito simples para "mapear" seu controle. Na figura 2 temos um circuito simples usando um sensor IR ligando a saída do seu Arduino. Quando qualquer botão do controle for apertado o Arduino irá receber o sinal via porta 11.

Figura 2. Circuito simples para receber dados de controle IR

Para verificar o código de cada botão, iremos pressionar um botão qualquer do controle. O sinal emitido pelo controle será capturado pelo Arduino através do sensor IR e repassado para a porta serial.  Na porta serial será possível associar cada botão a um código em Hexadecimal.
Para realizar esse e qualquer outro projeto usando sensores de IR, vamos precisar usar a biblioteca IRremote.h que pode ser facilmente achada na net. (Não sabe o que é uma biblioteca? clique aqui), os comando da biblioteca serão comentados no código abaixo:

Programa usado para códigos de cada botão do controle IR

#include <IRremote.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);  // indicando que pino 11 será usado como entrada de dados o sensor IR
decode_results results;

void setup()  
{
    Serial.begin(9600);   // incializa porta Serial
    irrecv.enableIRIn(); // Inicializa o receptor IR
}
 
void loop()  
{
    if (irrecv.decode(&results)) //verifica se algo foi capturado no sensor IR
   {
       Serial.println(results.value, HEX); //Exibir na serial valor em Hexa lido no sensor
       irrecv.resume();  //Le o próximo valor 
   }
}

Se tudo deu certo, agora você sabe qual a codificação de cada botão do controle.
Agora com base no circuito da figura 3, vamos controlar 4 Led's que serão ligados nas portas 4,5,6 e 7. Cada Led será ligado por um botão do controle (1,2,3 e 4) e todos os Leds serão apagados quando o botão 5 for pressionado.
Figura 3. Circuito de controle de Led's por controle IR.
Segue código equivalente  ao problema apresentado acima:

#include <IRremote.h>

int RECV_PIN = 11;
int pino1 = 7;
int pino2 = 6;
int pino3 = 5;
int pino4 = 4;

IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()  
{
    Serial.begin(9600);   // incializa porta Serial
    pinMode(pino1, OUTPUT);
    pinMode(pino2, OUTPUT);
    pinMode(pino3, OUTPUT);
    pinMode(pino4, OUTPUT);
    irrecv.enableIRIn(); // Inicializa o receptor IR  
}
 
void loop()
{
   if (irrecv.decode(&results))
  {
    Serial.println(results.value, HEX);
    irrecv.resume();
  }

    if (results.value == 0xFD08F7) //Verifica se a tecla 1 foi acionada  
    {
      digitalWrite(pino1, HIGH);  //Acende o led vermelho  
    }
    if (results.value == 0xFD8877) //Verifica se a tecla 2 foi acionada  
    {
      digitalWrite(pino2, HIGH); //Acende o led verde  
    }
    if (results.value == 0xFD48B7) //Verifica se a tecla 3 foi acionada  
    {
      digitalWrite(pino3, HIGH); //Acende o led Amarelo  
    }
    if (results.value == 0xFD28D7) //Verifica se a tecla 4 foi acionada
    {
      digitalWrite(pino4, HIGH); //Acende o led azul  
    }
    if (results.value == 0xFDA857) //Verifica se a tecla 5 foi acionada  
    {
      //Apaga todos os leds  
      digitalWrite(pino1, LOW);
      digitalWrite(pino2, LOW);
      digitalWrite(pino3, LOW);
      digitalWrite(pino4, LOW);
    }
 
}


Agora Pratique:

Exercício 1. Reproduza o mesmo projeto apresentado na figura 3 e adicione mais tres funções ao controle:

      - O botão "play" fará todos os Led's piscarem ao mesmo tempo com intervalo de 0,5s.
   - O botão "avançar" fará com que os Led's acendam de maneira sequencial da direita para a esquerda com intervalos de 0,5s 
    - O botão "retroceder" fará com que os Led's acendam de maneira sequencial da esquerda para a direita com intervalos de 1s
Na figura 4 temos os botões que serão usados nessa automação 
Figura 4. Botões que serão usados

Exercício 2. Reproduza o mesmo projeto apresentado no exercício 1 só que agora a frequência com os Led's irão oscilar pode variar. Neste projeto, cada numero do controle representará uma velocidade (e.g.   botão 1 = 0,1 s - botão 8 = 0,8s, etc)

Desafio:

Desafio 1. Agora que você já domina o uso de controles IR, tente controlar dois motores CC usado uma ponte H e o controle IR. Não sabe controlar motor CC ou usar a ponte H? Acesse nossa postagem sobre assunto clicando aqui.

Desafio 2. Você tem controle de vídeo-game, TV ou celular que possui IR na sua casa? Tente fazer uma automação de maneira semelhante ao vídeo que pode ser acessado clicando na figura abaixo.


 Clique aqui e assista um vídeo sobre o assunto no Youtube.


Ainda ta com duvida, curta nossa pagina no facebook no link abaixo e poste sua duvida lá.


Projeto Guerra de Robôs - Regras e dicas

Será entregue a cada grupo um Kit plataforma robótica similar a plataforma da figura 1 onde cada KIT composta por um chassi de plástico, dois motores DC, juntamente com parafusos e peças adicionais.
Figura 1. Plataforma robotica que será programada no Arduino

O grupo ficará responsável pelo equipamento devendo entregar em perfeito estado sob pena de punição em caso de avaria ou não devolução do equipamento;

Em caso de punição o professor deliberará sobre.

Regras e metricas para construção do Robo:


1)Todos os grupos deverão programar a plataforma arduino UNO para controle do veículo a ser desenvolvido;

2)O modelo, chassi e tamanho é livre, mas os grupos que assim quiserem iremos disponibilizar um chassi padrão que poderá ser utilizado como estrutura do veículo;

3)Não há limite para a massa total do robô;

4) A forma de controle do robô será de escolha do grupo de alunos podendo ser um controle com fio, wifi ou mesmo um robô autônomo;

5) Os sensores e atuadores utilizados no robô serão determinados pelos alunos deste de que obedeçam as regras anteriores e não violem nenhum regra abaixo;
1ª Competição de robos -  Junho 2017


Proibições e restrições:

6) Os ataques não poderão utilizar líquidos inflamáveis, fogos de artifício ou qualquer outra substância comburente ou inflamável;

7) Não será permitida a indução de descargas elétricas como forma de ataque;

8) Nos ataques realizados não poderão ser lançados objetos contra plateia ou robô oponente;


A condução da luta bem como o juizado ficará a cargo do professor que será responsável por declarar o vencedor e por deliberar sobre desclassificações ;
    *O não cumprimento das regras acima eliminará automaticamente o competidor


Semifinalistas da competição do 1ª TRC (2017-1)
Batalha e Vencedores:


    - A batalha terá 3 minutos de duração, 
    - Vence o robô que conseguir virar o robô do oponente ou empurrar-lo para fora da arena
    - A luta ocorrerá numa área delimitada,
           -Quem jogar o oponente para fora da area somará 1 ponto,
           -Quem virar o veículo do adversário somará 2 ponto.

Em caso de empate o robô mais leve irá ganhar!!!!!!


* Serão realizadas lutas eliminatórias até se determinar um vencedor por turma;




Alunos do 1ª TRC (2017-1) da faculdade Impacta
Relatório técnico:


Ainda ta com duvida, curta nossa pagina no facebook no link abaixo e poste sua duvida lá.



Bibliotecas no Arduino

As bibliotecas são fundamentais para o desenvolvimento de programas em C. Caracterizadas como um conjunto de rotinas padronizadas da linguagem, as bibliotecas contém funções de entrada/saída e processamento de informações.  O uso de uma biblioteca facilita o desenvolvimento de aplicações, pois para que a função digitalRead leia o valor de tensão na entrada de uma porta qualquer, alguém já programou algumas dezenas de linhas indicando como o digitalRead irá acessar a porta, coletar o valor e definir se esse valor é HIGH ou LOW. Ao adicionar uma biblioteca ao seu projeto, as funções contidas nessa biblioteca podem ser acessadas e utilizadas pelo desenvolvedor.
Além de facilitar nossa vida, é nas bibliotecas que o compilador irá verificar se as funções que você digitou não contem nenhum erro de sintaxe, ou seja, se você escreveu o comando corretamente.
Ao contrario da programação C convencional, no Arduino a biblioteca padrão (core) não precisa ser declarada, por isso que quando você usa algumas funções como digitalRead, digitalWrite, Serial.begin e analogRead (entre outras) o programa "roda" normalmente.

Como as bibliotecas na verdade são códigos adicionais, a IDE do Arduino não adiciona todas as bibliotecas que ele possui para não utilizar recursos de memória sem necessidade, sendo assim, quando um projeto requer o uso de uma biblioteca adicional, o desenvolvedor deve adiciona-la através do comando #include.

Além das funções básicas do Arduino, segue uma relação com as principais bibliotecas que podem ser usadas no seu projeto.


#include EEPROM.h 

Usada para ler e gravar dados em uma memória EEPROM no Arduino. No Arduino Uno a EEPROM tem o tamanho de 1024 bytes, no ATmega328 a capacidade da EEPROM é de 1024 bytes  e no ATmega168 e ATmega8 a capacidade é de 4096 bytes. Dentre as funções dessas bibliotecas temos:
read(), write(), update(), get(), put(),EEPROM[]...

#include Ethernet.h

Permite conectar o Arduino à Internet ou à rede local usando um shield Ethernet. Dentre as funções dessas bibliotecas temos:
begin(), localIP(), maintain(), IPAddress(), etc...

Também não podia deixar de citar que ela retorna o valor absoluto de um número inteiro usando abs.

#include LiquidCrystal.h

Com essa biblioteca podemos controlar displays de cristal líquido (LCD). Dentre as funções dessas bibliotecas temos:
LiquidCrystal(), begin(), clear(), home(), setCursor(), write(), print() etc....


#include SD.h

 Biblioteca muito importante, usada para que seja possível escrever e ler dados em cartões de memória SD/SDHC.Dentre as funções dessas bibliotecas temos:
begin(), exists(), mkdir(), open(), remove(), rmdir(), etc


Além das bibliotecas citadas acima, a IDE do Arduino possui outras que não foram citadas como SPI (Serial Peripheral Interface), a  Servo usada para controlar motores servo e a WiFi que permite conexão à uma rede (LAN e/ou WAN)por meio de um shield WiFi. Para conhecer outras bibliotecas e aprender mais sobre a sintaxe das funções contidas nessas bibliotecas, Clique aqui e acesse o site do Arduino.

Bibliotecas desenvolvida e disponibilizadas por desenvolvedores "Anônimos" também podem ser incluídas no seus projetos, para o Arduino reconhecer essas bibliotecas basta adiciona-la IDE do Arduino conforme indicado na Figura 1.
Figura 1. IDE Arduino - Instalando e selecionando bibliotecas.



Ainda ta com duvida, curta nossa pagina no facebook no link abaixo e poste sua duvida lá.