Tradutor

Pesquisar este blog

segunda-feira, 27 de junho de 2016

Trilho - alternativa para trabalhar com Robótica Educativa.

Componentes necessários para o robô Trilho: 
1) dois motores DC funcionando de 3 à 6 volts, que tornam possível a movimentação; 
2) São controlados por uma ponte H modelo L298N que efetiva o chaveamento de componentes no método PWM determinando a polaridade e o modo de tensão no circuito; 
3) O controle da ponte H é feito com uma placa de microcontrolador Arduino Uno
baseado no Atmega328; 
4) A tensão de operação é provida de duas baterias com 4.2V cada; 
5) A fim de permitir conexões de alimentação de componentes, 
usa-se o Arduino Sensor Shield V4.0; 
6) A obtenção de precisão na rotação do carinho foi alcançada através de um giroscópio ITG/MPU 6050; 
7) A comunicação remota com o dispositivo móvel é feita a partir de um módulo Bluetooth HC-06 FC114.
 Abaixo o esquemático do robô:

Código para comunicação entre robô e aplicativo: https://drive.google.com/file/d/0B73cMUeKCCw4OW9ER2lHaUpQRzQ/view
Bibliotecas adicionais para o incorporar a librares: https://drive.google.com/file/d/0B73cMUeKCCw4U3dtREFGREo2UDA/view
O aplicativo foi desenvolvido com auxílio do AppInventor, ambiente de desenvolvimento orientado a eventos para sistemas móveis do MIT (Massachussets Institute of Tecnology).
Mais informações sobre o AppInventor: http://appinventor.mit.edu/explore/ai2/setup-emulator.html#step2
Projeto para o aplicativo Trilho: https://drive.google.com/file/d/0B73cMUeKCCw4UV9jdDZqTHFLdW8/view

Conto infantil para introduzir o trabalho com robótica com crianças:
Gugu e sua máquina inteligente.
https://drive.google.com/file/d/0B73cMUeKCCw4UjFXWTF0VEFHQU0/view

quarta-feira, 18 de novembro de 2015

Medindo temperatura com LM35 e processing

Compontentes utilizados:
6x sensores LM35
1x Placa arduino uno

As ligações deveram ser feitas no arduino conforme esquema abaixo:



Imagem do software de geração de temperatura

O código (em processing) pode ser encontrado no link abaixo:
http://pastebin.com/rysD8NvV
Para compilar o código é necessário a IDE do processing que pode ser encotrada para download no seguinte link:
https://processing.org

sexta-feira, 19 de setembro de 2014

Ponte H

Movimentando Cooler12 V  com ponte H- Ardumoto- Motor Driver Shield



Código Utilizado 


#define CW  0
#define CCW 1

// Motor definitions to make life easier:
#define MOTOR_A 0
#define MOTOR_B 1

// Pin Assignments //
// Don't change these! These pins are statically defined by shield layout
const byte PWMA = 3;  // PWM control (speed) for motor A
const byte PWMB = 11; // PWM control (speed) for motor B
const byte DIRA = 12; // Direction control for motor A
const byte DIRB = 13; // Direction control for motor B

void setup()
{
  setupArdumoto(); // Set all pins as outputs
}

void loop()
{
  // Drive motor A (and only motor A) at various speeds, then stop.
  driveArdumoto(MOTOR_A, CCW, 255); // Set motor A to CCW at max
  delay(1000);  // Motor A will spin as set for 1 second
  driveArdumoto(MOTOR_A, CW, 127);  // Set motor A to CW at half
  delay(1000);  // Motor A will keep trucking for 1 second
  stopArdumoto(MOTOR_A);  // STOP motor A

  // Drive motor B (and only motor B) at various speeds, then stop.
  driveArdumoto(MOTOR_B, CCW, 255); // Set motor B to CCW at max
  delay(1000);  // Motor B will spin as set for 1 second
  driveArdumoto(MOTOR_B, CW, 127);  // Set motor B to CW at half
  delay(1000);  // Motor B will keep trucking for 1 second
  stopArdumoto(MOTOR_B);  // STOP motor B

  // Now spin both!
  driveArdumoto(MOTOR_A, CW, 255);  // Motor A at max speed.
  driveArdumoto(MOTOR_B, CW, 255);  // Motor B at max speed.
  delay(1000);  // Drive forward for a second
  // Now go backwards at half that speed:
  driveArdumoto(MOTOR_A, CCW, 127);  // Motor A at max speed.
  driveArdumoto(MOTOR_B, CCW, 127);  // Motor B at max speed.
}

// driveArdumoto drives 'motor' in 'dir' direction at 'spd' speed
void driveArdumoto(byte motor, byte dir, byte spd)
{
  if (motor == MOTOR_A)
  {
    digitalWrite(DIRA, dir);
    analogWrite(PWMA, spd);
  }
  else if (motor == MOTOR_B)
  {
    digitalWrite(DIRB, dir);
    analogWrite(PWMB, spd);
  } 
}

// stopArdumoto makes a motor stop
void stopArdumoto(byte motor)
{
  driveArdumoto(motor, 0, 0);
}

// setupArdumoto initialize all pins
void setupArdumoto()
{
  // All pins should be setup as outputs:
  pinMode(PWMA, OUTPUT);
  pinMode(PWMB, OUTPUT);
  pinMode(DIRA, OUTPUT);
  pinMode(DIRB, OUTPUT);

  // Initialize all pins as low:
  digitalWrite(PWMA, LOW);
  digitalWrite(PWMB, LOW);
  digitalWrite(DIRA, LOW);
  digitalWrite(DIRB, LOW);
}


Foi usado o seguinte site como referencia: https://www.sparkfun.com/products/9815

quarta-feira, 3 de setembro de 2014

Sensor de Chuva


Objetivo: Quando tiver presença de água nas trilhas metálicas da placa, o LED para de piscar, voltando a piscar quando estiver seco.

O sensor de chuva utilizado foi o modelo 529. Que é uma placa pronta para uso, a qual  possui 3 fios, sendo um VCC (que pode ser ligado em 5V), outro GND e outro SIG que é o pino de sinal analógico.
Quando as trilhas metálicas do sensor estão secas, a resistência entre elas é muito grande, resultando o SINAL próximo de 0V. Ao cair água nas trilhas, a resistência entre elas diminui, fazendo com que o SINAL se aproxime de 5V.
Exemplo com Arduino
Pino 13 do Arduino (coloque o pino 13 como OUTPUT e HIGH) no VCC do Sensor;
Pino GND do Arduino no GND do Sensor;
Pino ANALOG 0 do Arduino no SIG do Sensor;
Atenção: Coloque o pino 13 em nível LOW após fazer a leitura do sensor. Ao deixar o VCC do sensor sempre ligado em 5V irá ocorrer um fenômeno químico chamado eletrólise que com o passar o tempo danificará o sensor.
OBS: A imagem do sensor é meramente ilustrativa
 Código Arduino

int led = 6;
int sensordechuva = 0;
int val = 0;
void setup()
{
    pinMode(led,OUTPUT);
    pinMode(sensordechuva,INPUT);
    pinMode(13,OUTPUT);

    Serial.begin(9600);
}
void loop()
{
    digitalWrite(13,HIGH);
    val=analogRead(sensordechuva);
    digitalWrite(13,LOW);
     if(val==0)
    {
        digitalWrite(led,HIGH);
        delay(500);
        digitalWrite(led,LOW);
    }
    else
    {
        digitalWrite(led,LOW);
    }
    delay(500);
}

segunda-feira, 1 de setembro de 2014

Radio - Air module 915MHz






Para configurar o rádio é necessário fazer o download do seguinte software
http://vps.oborne.me/3drradioconfig.zip
Clique no botão "Load Settings" altere as configurações e clique em "Save Settings".
Lembrando que os dois rádios devem ter a mesma configuração baud_rate para funcinar normalmente

segunda-feira, 25 de agosto de 2014

Sensor de umidade


Figura 1: Sensor de umidade modelo 528 com Arduino UNO.

Nesse sensor, quando as duas ponteiras metálicas estão em contato com o solo seco, a resistência entre as ponteiras é muito grande, resultando o sinal próximo de 0V. Conforme o solo vai ficando úmido, a resistência entre as ponteiras diminui, fazendo com que o sinal se aproxime de 5V.

Exemplo com Arduino:
- pino 13 do Arduino (coloque o pino 13 como OUTPUT e HIGH) no VCC do sensor;
- pino GND do Arduino no GND do sensor;
- pino ANALOG 0 do Arduino no SIG do sensor.


Figura 2: Esquema elaborado no Fritzing (fritzing.org).


ATENÇÃO: Coloque o pino 13 em nível LOW após fazer a leitura do sensor. Ao deixar o VCC do sensor sempre ligado em 5V irá ocorrer um fenômeno químico chamado eletrólise que com o passar o tempo danificará o sensor.

Esse sensor entrega ao Arduino um sinal que varia entre 0 a 5V (0 a 1023 no Arduino), deste modo, é possível especificar alcances de umidade relativa do solo e assim caracterizar se o solo está mais ou menos úmido.

FONTE:

http://www.webtronico.com/sensor-de-umidade-de-solo.html
http://arduinobymyself.blogspot.com.br/2013/09/sistema-de-irrigacao.html

CÓDIGO ARDUINO:

int sensor = 0;
int sensor_val;

int sensorVCC = 13;

void setup()
{
  pinMode(sensor, OUTPUT);
  pinMode(sensorVCC, OUTPUT);
  Serial.begin(9600); // ABRE PORTA SERIAL A 9600bps
}

void loop()
{
  digitalWrite(sensorVCC, HIGH); // LIGA OS 5V PARA MEDIR
 
  sensor_val = analogRead(sensor); // LÊ O VALOR DO SENSOR
 
  digitalWrite(sensorVCC, LOW); // DESLIGA OS 5V PARA EVITAR ELETRÓLISE
 
  Serial.print("Valor de umidade lido: ");
  Serial.println(sensor_val); // MOSTRA O VALOR DO SENSOR
 
  delay(5000); // ESPERA 5s PARA MEDIR NOVAMENTE

}

quinta-feira, 10 de julho de 2014

Módulo Bluetooth no arduino

-Componentes: Arduino + Módulo Bluetooth BT_BOARD V1.3
-Descrição: Enviar dados para um arduino através de um módulo bluetooth

Enviando através da porta serial



Código:
void setup() {
 Serial.begin(9600);
 pinMode(13,OUTPUT);
}
char carac;
void loop() {
 if (Serial.available())
 {
   carac = Serial.read();
   if(carac=='L')
     digitalWrite(13,HIGH);
   if(carac=='D')
     digitalWrite(13,LOW);
 }
 delay(1);
}

Também pode ser feita através de uma porta PWM (por exemplo nos pinos digitais 5 e 6 ao invés de 1 e 2)


#include <SoftwareSerial.h>

SoftwareSerial bt(5, 6); // RX, TX

void setup() {
 Serial.begin(9600);
 pinMode(13,OUTPUT);
}
char carac;
void loop() {
 if (bt.available())
 {
   carac = bt.read();
   if(carac=='L')
     digitalWrite(13,HIGH);
   if(carac=='D')
     digitalWrite(13,LOW);
 }
 delay(1);
}

segunda-feira, 9 de junho de 2014

Tela 16x2 LED (arduino)








Codigo:


#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2);

int backLight = 13;    // pino 13 irá controlar a luz de fundo.

void setup()
{
  pinMode(backLight, OUTPUT);
  digitalWrite(backLight, HIGH); // Liga a luz de fundo (LOW desliga).
  lcd.begin(16,2);              // Colunas, linhas.  se usa 16x2 em uma tela 16x2 e assim por diante...
  lcd.clear();                  // Como não usaremos um "" temos que limpar a tela antes de iniciar senão tudo ficará preto.
  lcd.setCursor(0,0);           // Coloca o cursor na linha 0, linha 0 (é a primeira linha).
  lcd.print("Hellow World!");    // Digite o que você quiser que apareça na tela.
  lcd.setCursor(0,1);           // Coloca o cursor na coluna 0, linha 1.
  lcd.print("Gepid 2014.");
}

void loop()
{
}

segunda-feira, 1 de abril de 2013

Carro detecta ima


-Componentes: slot de pilhas + sensor de ima + fios + Radio frequência apc220 + Arduíno.

-Descrição: O carro foi feito no proposito de deslizar em um trilho que contem uma especie de régua e a cada 25 cm desta "régua" contem um ima, cada vez que o carro passa pelo ima o sensor vai informar o tempo da passada.




Código:

#define sensorPin 4    

int sensorState;                    // variável a guardar estado do botão
int lastsensorState;                // variável a guardar o último estado do botão
long startTime ;                    // momento de partida do cronômetro
long elapsedTime ;                  // tempo decorrido no cronômetro
int fractional;   
int cont = 0;
int i = 0;
int valor = 0;

void setup()
{
  Serial.begin(9600);
  pinMode(sensorPin, INPUT);     
  digitalWrite(sensorPin, LOW); 
  lastsensorState = LOW;
}


void loop(){

  if(digitalRead(sensorPin) == HIGH){ 
    startTime = millis();
    delay(300);
    while( cont < 3){
      sensorState = digitalRead(sensorPin);
      if(sensorState==HIGH && lastsensorState==LOW){
        elapsedTime = millis() - startTime;  // guarde tempo decorrido
        // rotina para exibir tempo decorrido 
        Serial.print( (int)(elapsedTime / 1000L));         // divida por 1000 para converter a segundos - e então converta a inteiro
        Serial.print(".");                   // imprima ponto decimal

        // use operador módulo para obter parte fracionária part do tempo 
        fractional = (int)(elapsedTime % 1000L);

        // preencha com zeros à esquerda - não seria ótimo se 
        // a linguage Arduino tivesse algo específico para tratar disso? :)
        if (fractional == 0)
          Serial.print("000");      // inclua 3 zeros
        else if (fractional < 10)
          Serial.print("00");       // inclua 2 zeros
        else if (fractional < 100)
          Serial.print("0");        // inclua 1 zero

        Serial.println(fractional); 
        cont ++;
        delay(300);
      }
      lastsensorState = sensorState;
    }
    cont = 0;
  }
}


segunda-feira, 18 de março de 2013

Carro com variação de velocidade.

-Componentes: Arduíno + 2 motores + fios + protoboard + suporte para pilha + dois TIP122 + 2 resistores.

-Descrição: Um projeto básico, mas que nos faz entender melhor a funcionalidade dos motores.
Este carro tem a seguinte ação, o motor começa com sua velocidade minima e ao passar do tempo sua velocidade é aumentada e mostrada no monitor.





Codigo:


int PortPin2 = 2;    // Motor 1
int PortPin3 = 3;    // Motor 1
int PortPin5 = 5;    // Motor 2
int PortPin6 = 6;    // Motor 2
int vel=0;
boolean lol=true;

void setup() {
  Serial.begin(9600); 
  pinMode(PortPin2, OUTPUT);
  pinMode(PortPin3, OUTPUT);
  pinMode(PortPin5, OUTPUT);
  pinMode(PortPin6, OUTPUT);
  analogWrite(PortPin3, LOW);  
  analogWrite(PortPin5, LOW); 
}

void loop() {
  if(lol == true){
    if(vel<255){
      for(int i=0;i<=255;i++){
        vel=i;
        analogWrite(PortPin3, vel);     //Motor 1
        analogWrite(PortPin5, vel);     //Motor 2
        Serial.println(vel);
        delay(100);

      }
    }
    else{
      delay(3000);
      for(int i=255;i>0;i--){
        vel=i;
        analogWrite(PortPin3, vel);     //Motor 1
        analogWrite(PortPin5, vel);     //Motor 2
        Serial.println(vel);
        delay(100);
      }
      lol= false;
    }
  }
}

quarta-feira, 16 de janeiro de 2013

Motor-de-passo com CI ULN2803.

-Componentes: 1 Motor de Passo, 4 leds, 4 resistores de 5 volts, 1 CI ULN2803, 4 resistores 1k, fios, arduino.

-Descrições: Projeto utilizando CI ULN2803 para controlar motor-de-passo bipolar, o leds foram usados para imitar o que esta acontecendo com as bobinas dentro do motor-de-passo.

Imagens: 

Código:


//PASSO COMPLETO

int time=100;

void setup()
{
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
}
void loop()
{
digitalWrite(3,HIGH);
delay(time);
digitalWrite(3,LOW);
delay(time);
digitalWrite(4,HIGH);
delay(time);
digitalWrite(4,LOW);
delay(time);
digitalWrite(5,HIGH);
delay(time);
digitalWrite(5,LOW);
delay(time);
digitalWrite(6,HIGH);
delay(time);
digitalWrite(6,LOW);
delay(time);
}



//MEIO PASSO:

int time= 100;

void setup()
{
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
}
void loop()
{
digitalWrite(3,HIGH);
delay(time);
digitalWrite(4,HIGH);
delay(time);
digitalWrite(3,LOW);
delay(time);
digitalWrite(5,HIGH);
delay(time);
digitalWrite(4,LOW);
delay(time);
digitalWrite(6,HIGH);
delay(time);
digitalWrite(5,LOW);
delay(time);
digitalWrite(3,HIGH);
delay(time);
digitalWrite(6,LOW);
}

segunda-feira, 19 de novembro de 2012

Passo 7 - Radio Frequência (apc220)


Componentes:

- 2x APC220 Módulos de RF com antenas
- 1x USB-TTL Converter
- 1x placa arduino + fios
- 1x sensor de temperatura
- 1x resistor 330Ω

- Descrição: O arduino  faz a leitura da temperatura através do sensor,  ao mesmo tempo envia os dados da leitura por um emissor wireless e por fim o computador recebe os dados pelo receptor ligado ao USB-TTL Converter.



- Ligações do arduino: 





-Receptor + conversor:





Instalação dos drivers: 

-Faça o download do driver clicando aqui (CP210x_VCP_Win_XP_S2K3_Vista_7) e instale-o.
-Programa para sincronizar a frequência do módulos, clique aqui (APC22X_V12A).

-Conecte o um dos módulos,  altere  a frequência para sua frequência desejada (max 478MHz).
-Repita o passo acima com o outro módulo.



-Código do Arduíno:


 int sensorPin = 0;

 int val = 0;

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

 }

void loop(){

   val = analogRead(sensorPin);
   
   Serial.println(val);

}

-Faca upload do código

-Abra a IDE do arduino e  escolha a serial port onde o receptor estiver conectado.

-Abra o serial monitor e seja feliz.



segunda-feira, 5 de novembro de 2012

Projeto - Carro segue trilha.



- Componentes: 2 Motores + 2 sensores de reconhecimento de cor + Placa Arduíno + Fios.

- Descrição: Na frente do carro temos dois sensores de luz, o carro vai identificar a intensidade luminosa que esta em baixo dele, a partir desses dados é feito um calculo para determinar as propriedades da superfície que ele se encontra, a cor, textura, ate mesmo uma linha preta no chão desde que o chão seja totalmente branco, ou pode seguir uma linha branca desde que o chão seja totalmente preto.





Código =>  SEGUIDOR DE LINHA REVERSO.

                 Código para robô segue linha reverso traciona o motor
                 de acordo com o curva assim ele reverte o polo
                 para dar o angulo de curvatura.


int PortPin2 = 2;    // Motor 1
int PortPin3 = 3;    // Motor 1
int PortPin4 = 4;    // Motor 2
int PortPin5 = 5;    // Motor 2
int Inp_sensor_dir = 8;
int Inp_sensor_esq = 9; 
void setup(){
    pinMode(PortPin2, OUTPUT); 
    pinMode(PortPin3, OUTPUT); 
    pinMode(PortPin4, OUTPUT); 
    pinMode(PortPin5, OUTPUT); 
    pinMode(Inp_sensor_dir, INPUT); 
    pinMode(Inp_sensor_esq, INPUT);   
} 
void loop(){
    drive_frente();     
    if((digitalRead(Inp_sensor_dir)) == HIGH){
          drive_esquerda();       
          delay(50);     
    }      
    drive_frente();
    if((digitalRead(Inp_sensor_esq))== HIGH){
          drive_direita();       
          delay(50);     
    }           
    drive_frente();      
}

void drive_esquerda(){   //função drive_esquerda
    digitalWrite(PortPin2, LOW);     //Motor 1
    digitalWrite(PortPin4, LOW);     //Motor 2
    digitalWrite(PortPin3, HIGH);    //Motor 1
    digitalWrite(PortPin5, HIGH);    //Motor 2
}
void drive_direita(){   //função drive_direita
    digitalWrite(PortPin2, HIGH);     //Motor 1
    digitalWrite(PortPin4, HIGH);     //Motor 2
    digitalWrite(PortPin3, LOW);      //Motor 1
    digitalWrite(PortPin5, LOW);      //Motor 2
}
void drive_frente(){    //função drive_frente
    digitalWrite(PortPin2, LOW);      //Motor 1
    digitalWrite(PortPin3, HIGH);      //Motor 1
    digitalWrite(PortPin4, HIGH);      //Motor 2
    digitalWrite(PortPin5, LOW);     //Motor 2
}


Codigo =>  SEGUIDOR DE LINHA DESLIGA.

                 Código para robô segue linha com deligamento
                 de um dos motor, para não dar o efeito de travamento.
           

int PortPin2 = 2;    // Motor 1
int PortPin3 = 3;    // Motor 1
int PortPin4 = 4;    // Motor 2
int PortPin5 = 5;    // Motor 2
int Inp_sensor_dir = 8;
int Inp_sensor_esq = 9; 
void setup(){
    pinMode(PortPin2, OUTPUT); 
    pinMode(PortPin3, OUTPUT); 
    pinMode(PortPin4, OUTPUT); 
    pinMode(PortPin5, OUTPUT); 
    pinMode(Inp_sensor_dir, INPUT); 
    pinMode(Inp_sensor_esq, INPUT);   
}
void loop(){

  drive_frente();     
  if((digitalRead(Inp_sensor_dir)) == HIGH){
  drive_esquerda();       
delay(200);     
  }      
  drive_frente();
  if((digitalRead(Inp_sensor_esq))== HIGH){
        drive_direita();       
delay(200);     
  }     
      
  drive_frente();      
}
void drive_esquerda(){  //função drive_esquerda
  //digitalWrite(PortPin2, LOW);  //Motor 1
  digitalWrite(PortPin4, LOW);    //Motor 2
  //digitalWrite(PortPin3, LOW);  //Motor 1
  digitalWrite(PortPin5, LOW);    //Motor 2
}

void drive_direita(){            //função drive_direita
  digitalWrite(PortPin2, LOW);    //Motor 1
  //digitalWrite(PortPin4, HIGH); //Motor 2
  digitalWrite(PortPin3, LOW);    //Motor 1
  //digitalWrite(PortPin5, LOW);  //Motor 2
}

void drive_frente(){              //função drive_frente
  digitalWrite(PortPin2, LOW);    //Motor 1
  digitalWrite(PortPin3, HIGH);   //Motor 1
  digitalWrite(PortPin4, HIGH);   //Motor 2
  digitalWrite(PortPin5, LOW);    //Motor 2
}