terça-feira, 31 de julho de 2012

Transientes

Um dos problemas que foram detectados durante uma simulação para um seguidor de linha que estava desenvolvendo no Simulino foi a presença de transientes, assim definidos no Wikipédia (http://pt.wikipedia.org/wiki/Transiente, acesso em 31/07):
"...é um surto de tensão elétrica que ocorre num intervalo de tempo muito pequeno...
  • O chaveamento de cargas fortemente indutivas, como os motores elétricos, gera transientes que são causados pela força contra eletro-motriz. Isso ocorre porque um indutor opõe-se à variação de corrente elétrica. Quando ocorre o desligamento de uma chave - eletrônica ou não - a energia armazenada sob a forma de campo magnético força a passagem de corrente em sentido inverso ao sentido original. O resultado é um pulso rápido de alta tensão, conhecido como "spike".
Os transientes são um dos maiores causadores da queima de equipamentos eletrônicos..."
Bom, o código segue abaixo:

/* Programa para leitura de 2 sensores IR - Projeto Robô Lutador de Sumô
Equipe Pequenos Cientistas 2012
Este programa é a base para um robo seguidor de linha e pode ser aplicado em arenas de fundo branco com linha preta ou fundo preto linha branca A variável maximo estipula o limite de tensão entre o estado ligado e desligado do sensor, ou seja, se a tensão lida no  sensor for inferior não há reflexão ou, caso contrário, há reflexão. Para controle se faz uso de uma ponte H - O L298N. Foi escolhido por suportar correntes maiores do que L293 e, ser mais barato.
*/
//Variáveis de pino analógico
int IR1=0;
int IR2=1;
//variáveis de pino digital
int L1 = 5;
int L2 = 6;
int L3 = 7;
int L4 = 8;

//variável dos sensores
int maximo = 3; // tensão de corte - sensor ativo ou desligado
int VR1;
int VR2;

//variável de acionamento dos motores
int m1 = 3;
int m2 = 4;

void setup() {
// configura o pino como saida
pinMode(L1, OUTPUT); //pino 5
pinMode(L2, OUTPUT); //pino 6
pinMode(L3, OUTPUT); //pino 7
pinMode(L4, OUTPUT); //pino 8
//configura acionamento de motores
pinMode(m1, OUTPUT);
pinMode(m2, OUTPUT);
// configura o pino como entrada
pinMode(IR1, INPUT); //pino A0
pinMode(IR1, INPUT); //pino A1

}
void loop(){
  
  // le o estado do sensor e converte para volts
VR1 = analogRead(IR1) * 0.0049;
VR2 = analogRead(IR2) * 0.0049;
digitalWrite(m1, HIGH);//aciona o MOTOR 1
digitalWrite(m2, HIGH);//desliga o MOTOR 2

// verifica se o sensor está ativo
if (VR1 > maximo) { // se ativo:
digitalWrite(L1, HIGH);//aciona o pino digital 5
digitalWrite(L2, LOW);//desliga o pino digital 6
}
else {// se desligado:
digitalWrite(L1, LOW);//desliga o pino digital 5
digitalWrite(L2, HIGH);//aciona o pino digital 6
}
//verifica se o sensor está ativo
if (VR2 > maximo){ // se ativo:
digitalWrite(L3, HIGH);//aciona o pino digital 7
digitalWrite(L4, LOW);//desliga o pino digital 8
}
else {//se desligado:
digitalWrite(L3, LOW);//aciona o pino 7
digitalWrite(L4, HIGH);//aciona o pino 8
}
//L1 – MOTOR DIREITO LIGADO
//L2 – MOTOR DIREITO INVERTIDO
//L3 – MOTOR ESQUERDO LIGADO
//L4 – MOTOR ESQUERDO INVERTIDO

}
Aqui segue o circuito elétrico que utilizei na simulação:
 
Bom, notaram que usei diodos de proteção na tentativa inútil de remover os transientes detectados durante a simulação. Resultado: não funcionou. Consultando o site do Newton Braga (http://www.newtoncbraga.com.br/index.php/robotica/1396-mec018.html) ele sugere: "Os capacitores em oposição em paralelo com o motor são importantes para eliminar transientes que tanto podem afetar os transistores como também o próprio circuito integrado, a partir da fonte de alimentação."
Bom não testei ainda mas em breve posto o resultados dos testes.

domingo, 29 de julho de 2012

Retorno às aulas

Retorno às aulas em 30/07. Reunião marcada para quarta 01/08.


O Dia dos Pais está Chegando!

Nesse dia dos Pais, não ande de um lado para o outro atrás do presente ideal, dê o descanço para seus pés e do seu Papai, venha nos visitar e confira a linha de Chinelos e Pijamas Masculino que a Citoka tem a Oferecer!


Leia mais: http://www.citoka.com/archive/news/

quarta-feira, 25 de julho de 2012

Comando While para sincronização de motores

Após sincronizar os motores surgiu um novo problema: os motores tem que girar por um tempo invertidos e depois retornar ao sincronismo original. Ou seja, após girar o robô, o robô deve seguir em frente novamente.
Para tanto, consultando a apostila de Linguagem Arduíno, do site Eaduino (www.eaduino.com.br), encontrei  o comando while. Segue abaixo trecho da apostila sobre o assunto:
"... 5.4 while
while( <expressão> ){
// declarações
}
A estrutura while repete as declarações enquanto a expressão resultar e um valor verdadeiro, ou seja, esta estrutura só termina quando a expressão se tornar falsa.
Exemplo
var = 0;
while(var < 200){
var++;
Serial.println( var );
}..."

A partir destas informações, construímos o código abaixo:

/*Uso do While em motores de passo */

//pinos de saída digital
//passo direito
int passo1 = 5;
int passo2 = 6;
int passo3 = 7;
int passo4 = 8;
//passo esquerdo
int passo5 = 9;
int passo6 = 10;
int passo7 = 11;
int passo8 = 12;
//tempo de passo
int passo = 100;
//tempo para girar 90°
int giro = 0;
// ————————————————————————— Setup
void setup() {
// Seleciona motores
//motor direito
pinMode(passo1, OUTPUT);
pinMode(passo2, OUTPUT);
pinMode(passo3, OUTPUT);
pinMode(passo4, OUTPUT);
//motor esquerdo
pinMode(passo5, OUTPUT);
pinMode(passo6, OUTPUT);
pinMode(passo7, OUTPUT);
pinMode(passo8, OUTPUT);

}
// ————————————————————————— Loop


void loop () {
//giro de 90°
while (giro<5){
digitalWrite (passo1, HIGH);
digitalWrite (passo8, HIGH);
delay (passo);
digitalWrite (passo1, LOW);
digitalWrite (passo8, LOW);
digitalWrite (passo2, HIGH);
digitalWrite (passo7, HIGH);
delay (passo);
digitalWrite (passo2, LOW);
digitalWrite (passo7, LOW);
digitalWrite (passo3, HIGH);
digitalWrite (passo6, HIGH);
delay (passo);
digitalWrite (passo3, LOW);
digitalWrite (passo6, LOW);
digitalWrite (passo4, HIGH);
digitalWrite (passo5, HIGH);
delay (passo);
digitalWrite (passo4, LOW);
digitalWrite (passo5, LOW);
delay (passo);
giro++;
}
//em frente
digitalWrite (passo1, HIGH);
digitalWrite (passo5, HIGH);
delay (passo);
digitalWrite (passo1, LOW);
digitalWrite (passo5, LOW);
digitalWrite (passo2, HIGH);
digitalWrite (passo6, HIGH);
delay (passo);
digitalWrite (passo2, LOW);
digitalWrite (passo6, LOW);
digitalWrite (passo3, HIGH);
digitalWrite (passo7, HIGH);
delay (passo);
digitalWrite (passo3, LOW);
digitalWrite (passo7, LOW);
digitalWrite (passo4, HIGH);
digitalWrite (passo8, HIGH);
delay (passo);
digitalWrite (passo4, LOW);
digitalWrite (passo8, LOW);

}


O resultado foi muito positivo, conforme pode ser visto no vídeo abaixo:


Sincronização de motores

 Um dos problemas observados com a programação que estamos utilizando é a sincronização de motores. Quando utilizamos este código:

/* Este código permite o passo de 2 motores
*/
//motor direito
int motorPin1 = 5;
int motorPin2 = 6;
int motorPin3 = 7;
int motorPin4 = 8;
//motor esquerdo
int motorPin5 = 9;
int motorPin6 = 10;
int motorPin7 = 11;
int motorPin8 = 12;

int delayTime = 500;

void setup() {
  //configura os pinos digitais do motor direito
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
  //configura os pinos digitais do motor esquerdo
  pinMode(motorPin5, OUTPUT);
  pinMode(motorPin6, OUTPUT);
  pinMode(motorPin7, OUTPUT);
  pinMode(motorPin8, OUTPUT);
}

void loop() {
//motor direito
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(delayTime);
  //motor esquerdo
  digitalWrite(motorPin5, HIGH);
  digitalWrite(motorPin6, LOW);
  digitalWrite(motorPin7, LOW);
  digitalWrite(motorPin8, LOW);
  delay(delayTime);
  digitalWrite(motorPin5, LOW);
  digitalWrite(motorPin6, HIGH);
  digitalWrite(motorPin7, LOW);
  digitalWrite(motorPin8, LOW);
  delay(delayTime);
  digitalWrite(motorPin5, LOW);
  digitalWrite(motorPin6, LOW);
  digitalWrite(motorPin7, HIGH);
  digitalWrite(motorPin8, LOW);
  delay(delayTime);
  digitalWrite(motorPin5, LOW);
  digitalWrite(motorPin6, LOW);
  digitalWrite(motorPin7, LOW);
  digitalWrite(motorPin8, HIGH);
  delay(delayTime);
}

Você vai notar no vídeo abaixo que os leds piscam fora de sincronia, ou seja, os motores girariam primeiro o direito e depois o esquerdo.
Uma das soluções foi ligar os dois motores nos pinos digitais de 8 a 12 e ligar o comando "Enable A/B" dos l297 em outros dois pinos digitais.
O grande problema reside no fato que somente um motor giraria e o outro ficaria parado. Não é possível por exemplo, girar o motor direito num sentido e o motor esquerdo em outro sentido. Isso causa no robô o comportamento de girar aberto. Com um motor num sentido e outro no sentido inverso, além de girar aberto, você pode girar fechado, o que aumenta as possibilidades de manobras evasivas.
O código abaixo foi testado com leds mas ilustra o giro em sentidos opostos dos motores, bastando pequenas correções no código acima, além de ocupar menos bytes.
/*Testes de Passo - Código utilizado para 2 motores de passo*/
//motor direito
int motorPin1 = 5;
int motorPin2 = 6;
int motorPin3 = 7;
int motorPin4 = 8;
//motor esquerdo
int motorPin5 = 9;
int motorPin6 = 10;
int motorPin7 = 11;
int motorPin8 = 12;

//tempo de passo
int passo = 50;

void setup() {
  //define os pinos digitais do motor direito
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
  //define os pinos digitais do motor esquerdo
  pinMode(motorPin5, OUTPUT);
  pinMode(motorPin6, OUTPUT);
  pinMode(motorPin7, OUTPUT);
  pinMode(motorPin8, OUTPUT);
}

void loop() {
  //motor de passo direito e esquerdo, sincronizado
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin5, HIGH);
    delay(passo);
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin5, LOW);
  digitalWrite(motorPin6, HIGH);
    delay(passo);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin6, LOW);
  digitalWrite(motorPin7, HIGH);
  delay(passo);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin7, LOW);
  digitalWrite(motorPin8, HIGH);
  delay(passo);
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin8, LOW);
  }

O vídeo do resultado no Simulino.


Este código ainda não utiliza funções até pelos testes mas, como base de estudo, ajuda muito.

Sensor IR com função

O código de sensor IR anterior, mas agora com função, o que torna o código mais eficiente e limpo:

int IR[]={0,1,2,3,4,5};

int L[] ={6,7,8,9,10,11};

int maximo = 3;
int VR[]={1,2,3,4,5,6};

void setup() {
// configura o pino como saida
int a;
for (a=0; a<6; a++){
pinMode(L[a], OUTPUT);

// configura o pino como entrada
pinMode(IR[a], INPUT);
}

}
void loop(){
int a;
for (a=0; a<6; a++){
 
  // le o estado do botao
VR[a] = analogRead(IR[a])*0.0049;
// verifica se o sensor está ativo
if (VR[a] >= maximo) {
// se sim, acende o LED
digitalWrite(L[a], HIGH);
}
else{
  digitalWrite(L[a], LOW);
}
}
}

terça-feira, 24 de julho de 2012

Teste Virtual do TITAN I - Simulino

Após o teste dos sensores utilizando led´s, agora testamos o programa em motores de passo no Simulino. O resultado foi positivo. O programa está pronto, falta a parte de chassi e placas.


Teste - sensores ativando o passo e motores

O filme abaixo apresenta o teste em Simulino apresentando 6 sensores ativando 2 motores (led´s verdes) e o passo utilizado nestes motores (led´s azuis). O objetivo e controlar sincronicamente 2 motores de passo utilizando 6 sensores e o Arduino.


 O código fonte utilizado está "sujo", ou seja, ainda não usa equações, vetores ou funções para obter o resultado final e, tem opção de 4 pinos digitais para ativação de motores.

/* Programa para leitura de 6 sensores IR - Projeto Robô Lutador de Sumô
Equipe Pequenos Cientistas 2012
*/
//variavel dos pinos analogicos
int IR1=0;
int IR2=1;
int IR3=2;
int IR4=3;
int IR5=4;
int IR6=5;

//variavel dos pinos digitais
//pinos de ativação dos motores
//int L1 = 4;
//int L2 = 5;
int L3 = 6;
int L4 = 7;
//pinos do passo
int L5 = 8;
int L6 = 9;
int L7 = 10;
int L8 = 11;
//tempo do passo
int tempo = 500;

//variaveis de comparação da leitura dos pinos analogicos
//valor da tensão do pino analógico que determina o sinal
int maximo = 2;
//variaveis das diversas leituras
int VR1;
int VR2;
int VR3;
int VR4;
int VR5;
int VR6;

void setup() {
// configura o pino como saida
//pinMode(L1, OUTPUT);
//pinMode(L2, OUTPUT);
pinMode(L3, OUTPUT);
pinMode(L4, OUTPUT);
pinMode(L5, OUTPUT);
pinMode(L6, OUTPUT);
pinMode(L7, OUTPUT);
pinMode(L8, OUTPUT);

// configura o pino como entrada
pinMode(IR1, INPUT);
pinMode(IR1, INPUT);
pinMode(IR2, INPUT);
pinMode(IR3, INPUT);
pinMode(IR4, INPUT);
pinMode(IR5, INPUT);

Serial.begin (9600);
}
void loop(){
   
  // le o estado do botao
VR1 = analogRead(IR1) * 0.0049;
VR2 = analogRead(IR2) * 0.0049;
VR3 = analogRead(IR3) * 0.0049;
VR4 = analogRead(IR4) * 0.0049;
VR5 = analogRead(IR5) * 0.0049;
VR6 = analogRead(IR6) * 0.0049;

// verifica se o sensor está ativo
if (VR1 > maximo) {
// aciona os motores 1 e 2
//digitalWrite(L1, HIGH);
//digitalWrite(L2, HIGH);
digitalWrite(L3, HIGH);
digitalWrite(L4, HIGH);
//passo
digitalWrite(L5, HIGH);
delay(tempo);
digitalWrite(L5, LOW);
digitalWrite(L6, HIGH);
delay(tempo);
digitalWrite(L6, LOW);
digitalWrite(L7, HIGH);
delay(tempo);
digitalWrite(L7, LOW);
digitalWrite(L8, HIGH);
delay(tempo);
digitalWrite(L8, LOW);
}
else {
//desliga os motores 1 e 2
//digitalWrite(L1, LOW);
//digitalWrite(L2, LOW);
digitalWrite(L3, LOW);
digitalWrite(L4, LOW);
//desliga o passo
digitalWrite(L5, LOW);
digitalWrite(L6, LOW);
digitalWrite(L7, LOW);
digitalWrite(L8, LOW);
}

if (VR2 > maximo){
//aciona um dos motores, o outro desligado
//digitalWrite(L1, HIGH);
//digitalWrite(L2, HIGH);
digitalWrite(L3, LOW);
digitalWrite(L4, HIGH);
//passo
digitalWrite(L5, HIGH);
delay(tempo);
digitalWrite(L5, LOW);
digitalWrite(L6, HIGH);
delay(tempo);
digitalWrite(L6, LOW);
digitalWrite(L7, HIGH);
delay(tempo);
digitalWrite(L7, LOW);
digitalWrite(L8, HIGH);
delay(tempo);
digitalWrite(L8, LOW);
}
else {
//digitalWrite(L1, LOW);
//digitalWrite(L2, LOW);
digitalWrite(L3, LOW);
digitalWrite(L4, LOW);
}

if (VR3 > maximo) {
//aciona o outro dos motores, o anterior desligado
//digitalWrite(L1, LOW);
//digitalWrite(L2, LOW);
digitalWrite(L3, HIGH);
digitalWrite(L4, LOW);
//passo
digitalWrite(L5, HIGH);
delay(tempo);
digitalWrite(L5, LOW);
digitalWrite(L6, HIGH);
delay(tempo);
digitalWrite(L6, LOW);
digitalWrite(L7, HIGH);
delay(tempo);
digitalWrite(L7, LOW);
digitalWrite(L8, HIGH);
delay(tempo);
digitalWrite(L8, LOW);
}
else {
//digitalWrite(L1, LOW);
//digitalWrite(L2, LOW);
digitalWrite(L3, LOW);
digitalWrite(L4, LOW);
}

if (VR4 > maximo) {
// aciona os motores 1 e 2
//digitalWrite(L1, HIGH);
//digitalWrite(L2, HIGH);
digitalWrite(L3, HIGH);
digitalWrite(L4, HIGH);
//PASSO INVERTIDO
digitalWrite(L8, HIGH);
delay (tempo);
digitalWrite(L8, LOW);
digitalWrite(L7, HIGH);
delay (tempo);
digitalWrite(L7, LOW);
digitalWrite(L6, HIGH);
delay (tempo);
digitalWrite(L6, LOW);
digitalWrite(L5, HIGH);
delay (tempo);
digitalWrite(L5, LOW);

}
else {
//digitalWrite(L1, LOW);
//digitalWrite(L2, LOW);
digitalWrite(L3, LOW);
digitalWrite(L4, LOW);
}

if (VR5 > maximo) {
//digitalWrite(L1, HIGH);
//digitalWrite(L2, HIGH);
digitalWrite(L3, HIGH);
digitalWrite(L4, LOW);
//PASSO INVERTIDO
digitalWrite(L8, HIGH);
delay (tempo);
digitalWrite(L8, LOW);
digitalWrite(L7, HIGH);
delay (tempo);
digitalWrite(L7, LOW);
digitalWrite(L6, HIGH);
delay (tempo);
digitalWrite(L6, LOW);
digitalWrite(L5, HIGH);
delay (tempo);
digitalWrite(L5, LOW);
}
else {
//digitalWrite(L1, LOW);
//digitalWrite(L2, LOW);
digitalWrite(L3, LOW);
digitalWrite(L4, LOW);
}

if (VR6 > maximo) {
digitalWrite(L3, LOW);
digitalWrite(L4, HIGH);
//PASSO INVERTIDO
digitalWrite(L8, HIGH);
delay (tempo);
digitalWrite(L8, LOW);
digitalWrite(L7, HIGH);
delay (tempo);
digitalWrite(L7, LOW);
digitalWrite(L6, HIGH);
delay (tempo);
digitalWrite(L6, LOW);
digitalWrite(L5, HIGH);
delay (tempo);
digitalWrite(L5, LOW);
}
else {
//digitalWrite(L1, LOW);
//digitalWrite(L2, LOW);
digitalWrite(L3, LOW);
digitalWrite(L4, LOW);

}
}


segunda-feira, 23 de julho de 2012

Teste - Sensores de IR

 Este teste usa o Simulino, simulador do Arduino no Proteus, com o código fonte abaixo, para simular a leitura de sensores IR. Estes sensores serão utilizados no TITAN I e outros robôs, sendo o código adaptado para cada situação em particular. Os botões atuam fechando o circuito, ou seja, se um objeto refletir a luz IR o Arduíno recebe um sinal acendendo um led específico. O fator de multiplicação converte o sinal analógico do Arduíno em tensão.


/* Programa para leitura de 6 sensores IR - Projeto Robô Lutador de Sumô
Equipe Pequenos Cientistas 2012
*/
int IR1=0;
int IR2=1;
int IR3=2;
int IR4=3;
int IR5=4;
int IR6=5;

int L1 = 5;
int L2 = 6;
int L3 = 7;
int L4 = 8;
int L5 = 9;
int L6 = 10;


int maximo = 2;
int VR1;
int VR2;
int VR3;
int VR4;
int VR5;
int VR6;

void setup() {
// configura o pino como saida
pinMode(L1, OUTPUT);
pinMode(L2, OUTPUT);
pinMode(L3, OUTPUT);
pinMode(L4, OUTPUT);
pinMode(L5, OUTPUT);
pinMode(L6, OUTPUT);

// configura o pino como entrada
pinMode(IR1, INPUT);
pinMode(IR1, INPUT);
pinMode(IR2, INPUT);
pinMode(IR3, INPUT);
pinMode(IR4, INPUT);
pinMode(IR5, INPUT);

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

  // le o estado do botao
VR1 = analogRead(IR1) * 0.0049;
VR2 = analogRead(IR2) * 0.0049;
VR3 = analogRead(IR3) * 0.0049;
VR4 = analogRead(IR4) * 0.0049;
VR5 = analogRead(IR5) * 0.0049;
VR6 = analogRead(IR6) * 0.0049;

// verifica se o sensor está ativo
if (VR1 > maximo) {
// se sim, acende o LED
digitalWrite(L1, HIGH);
}
else {
digitalWrite(L1, LOW);
}

if (VR2 > maximo){
// caso contrario, apaga o LED
digitalWrite(L2, HIGH);
}
else {
digitalWrite(L2, LOW);
}


if (VR3 > maximo) {
// se sim, acende o LED
digitalWrite(L3, HIGH);
}
else {
digitalWrite(L3, LOW);
}

if (VR4 > maximo) {
// se sim, acende o LED
digitalWrite(L4, HIGH);
}
else {
digitalWrite(L4, LOW);
}

if (VR5 > maximo) {
// se sim, acende o LED
digitalWrite(L5, HIGH);
}
else {
digitalWrite(L5, LOW);
}

if (VR6 > maximo) {
// se sim, acende o LED
digitalWrite(L6, HIGH);
}
else {
digitalWrite(L6, LOW);
}

}




O vídeo abaixo ilustra a execução do código.


Simulino - Simulador de Arduino

23/07/2013
Saiu a nova versão do Simulino - 2.0, com  muito mais funcionalidades e com novo design (rsrsrsrs). Além disso, esta nova versão você pode simular o sensor de ultrassom. Ou seja, agora é possível testar o programa do robô antes de construí-lo. Baixar leva alguns segundos e, ainda não testamos todas as funcionalidades mas damos os parabéns a equipe do Blog. Embarcado:
Link para baixar o simulino 2.0:
 http://blogembarcado.blogspot.com.br/2013/06/simulino-v20-biblioteca-para-proteus.html#comment-form

Link para o projeto de sensor de ultrassom:
http://blogembarcado.blogspot.com.br/2013/06/sensor-ultrassonico-v2.html

07/2012
Procurando um emulador de Arduino na Internet encontrei o Simulino - um simulador que utiliza o Proteus para agir como se fosse um Arduino UNO funcionando. Apanhei um pouco mas consegui testar o primeiro código - um programa para rodar um motor de passo bipolar com l298 (sem diodos de proteção). O bom é que não tem risco de queimar o Arduino.
Links para quem se interessar:
http://labdegaragem.com/profiles/blog/show?id=6223006%3ABlogPost%3A116712&commentId=6223006%3AComment%3A119207&xg_source=activity
http://blogembarcado.blogspot.com.br/2012/02/simulino-simulando-arduino.html

Proteus 7.7 Completo:
http://mecatronicadegaragem.blogspot.com.br/2010/09/proteus-77-pro-completo.html

Vídeo do Primeiro Teste com Simulino:
Código fonte utilizado:

/*Exemplo 1: exemplo simples
 *Motor de passo Copal
 * --------------------
 *
 * Programa para acionar um motor de passo proveniente de
 * um drive de disquete de 5'25
 * De acordo com a documentação encontrada, este motor:
 * "[...] motor
 * made by Copal Electronics, with 1.8 degrees per step and 96 ohms
 * per winding, with center taps brought out to separate leads [...]"
 * [http://www.cs.uiowa.edu/~jones/step/example.html]
 *
 * Trata-se de um motor de passo unipolar com 5 fios:
 *
 * - vermelho: alimentação, 5V pareceu-me bem
 * - laranja e preto: bobina 1
 * - marrom e amarelo: bobina 2
 *
 * (cleft) 2005 DojoDave para o K3
 * http://www.0j0.org | http://arduino.berlios.de
 *
 * @author: David Cuartielles
 * @date: 20 Out 2005
 */

int motorPin1 = 8;
int motorPin2 = 9;
int motorPin3 = 10;
int motorPin4 = 11;
int delayTime = 500;

void setup() {
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop() {
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(delayTime);
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(delayTime);
}

sexta-feira, 20 de julho de 2012

TUTORIAL SOBRE MOTOR DE PASSO

Recomendo este tutorial para motor de passo:
http://www.rogercom.com/pparalela/IntroMotorPasso.htm

É a nossa fonte mais consultada sobre o tema.

Sensores Infravermelho para Robôs de Sumo

 O projeto de robôs de sumo envolve o uso de sensores de linha, que normalmente são Infravermelhos (IR) e, sensores de distância, para identificar objetos. Os sensores de distância podem ser ultrassônicos (utilizam sons com frequências acima da audição humana) ou sensores de infravermelho. A escolha de infravermelho se deve ao custo deste em relação aos sensores de som - R$60,00 os de ultrassom, R$12,00 os IR e para fazer o sensor IR, cerca de R$5,00. A questão de fazer os sensores IR envolve a compra (TIL32 e TIL78 sofrem interferência da luza ambiente) e a montagem - o fototransistor é invertido, coisa que descobrimos do pior jeito (errando que se aprende).


 É importante destacar que o ideal é testar os sensores antes de utilizar. A estática da mão pode queimar o fototransistor e a temperatura do ferro de solda pode fazer o mesmo. O sistema proposto abaixo economiza, e muito, energia durante os combates. Não pode ser usado para medir distâncias, apesar das informações deste esquema no Multisim ter indicado que o LED IR "pisca" com uma frequencia de 24Khz. Sem um osciloscópio não arriscaria usar esse valor como referência. Se bem isolado, consegue até 10 cm de sensibilidade. 

O código abaixo pode ser utilizado para calcular a distância, mas o objetivo inicial deste código é apenas testar os 6 sensores.
/* Programa para leitura de 6 sensores IR - Projeto Robô Lutador de Sumô Equipe Pequenos Cientistas 2012
*/
int IR1=0;
int IR2=1;
int IR3=2;
int IR4=3;
int IR5=4;
int IR6=5;

int L1 = 5;
int L2 = 6;
int L3 = 7;
int L4 = 8;
int L5 = 9;
int L6 = 10;


int maximo = 400;
int VR1;
int VR2;
int VR3;
int VR4;
int VR5;
int VR6;

void setup() {
// configura o pino como saida
pinMode(L1, OUTPUT);
pinMode(L2, OUTPUT);
pinMode(L3, OUTPUT);
pinMode(L4, OUTPUT);
pinMode(L5, OUTPUT);
pinMode(L6, OUTPUT);

// configura o pino como entrada
pinMode(IR1, INPUT);
pinMode(IR1, INPUT);
pinMode(IR2, INPUT);
pinMode(IR3, INPUT);
pinMode(IR4, INPUT);
pinMode(IR5, INPUT);

Serial.begin (9600);
}
void loop(){
  
  // le o estado do botao
VR1 = analogRead(IR1);
VR2 = analogRead(IR2);
VR3 = analogRead(IR3);
VR4 = analogRead(IR4);
VR5 = analogRead(IR5);
VR6 = analogRead(IR6);

// verifica se o sensor está ativo
if (VR1 >= maximo) {
// se sim, acende o LED
digitalWrite(L1, HIGH);
}
if (VR2 >= maximo){
// caso contrario, apaga o LED
digitalWrite(L2, LOW);
}
if (VR3 >= maximo) {
// se sim, acende o LED
digitalWrite(L3, HIGH);
}
if (VR4 >= maximo) {
// se sim, acende o LED
digitalWrite(L4, HIGH);
}
if (VR5 >= maximo) {
// se sim, acende o LED
digitalWrite(L5, HIGH);
}
if (VR6 >= maximo) {
// se sim, acende o LED
digitalWrite(L6, HIGH);

}
}


Aliás, é possível utilizar este código para controlar o robô bastando substituir os leds com seus resistores por pontes H. Caso se interesse verifique nosso post anterior.


Abaixo uma sugestão de como montar uma placa com sensores IR para um robô de sumô 20x20 cm.





quinta-feira, 19 de julho de 2012

Mostra Nacional de Robótica

Encontram-se abertas até 01/09 as inscrições para a Mostra Nacional de Robótica (MNR) 2012.
Informações em: http://www.mnr.org.br
Além das publicações online e nos anais da MNR, a mostra distribuirá também para os melhores trabalhos:

- Bolsas de Iniciação Científica Junior do CNPq (*)
- Menções honrosas
- Auxílios para participação na Mostra Presencial, que ocorre em conjunto com a CBR, OBR, SBR, LARC e LARS (*).

Diferentemente da primeira edição, os trabalhos agora podem ser submetidos por qualquer aluno do ensino fundamental, médio, técnico ou superior, bem como pós-graduandos ou pesquisadores em ambos os formatos (multimídia ou artigo científico/tecnológico).
Atenciosamente,

Equipe MNR.
organizacao@mnr.org.br 

quarta-feira, 18 de julho de 2012

ENATER


ENATER


DETALHAMENTO 
Categoria: Prova Objetiva . Níveis: 1, 2, 3, 4


Conceito Básico do Exame: O exame consiste num conjunto de quatro provas objetivas (uma para cada nível) com intuito de solicitar, em níveis diferentes de complexidade, os conteúdos típicos da robótica desenvolvida no ambiente escolar. São motivo de atenção os temas mais abordados pelos cursos e projetos dessa área de conhecimento e que podem servir de embasamento teórico para o enfrentamento dos desafios apresentados no Torneio Juvenil de Robótica. Busca-se aqui estabelecer um parâmetro comum que sirva de referência básica para estimar o domínio conceitual do aluno frente às questões de tecnologia em robótica e suas conexões com as demais disciplinas de sua grade escolar. Diferentemente dos desafios, a prova do ENATER (que, em Latim, significa único) é uma atividade individual e sem consulta, composta de vinte questões objetivas, que deve ser resolvida, durante duas horas, online na escola, sob supervisão de um responsável local,no dia 13 de agosto, a partir dos textos disponibilizados nesse dia a todos os inscritos no Sistema Gaia que tenham recebido aval do supervisor local. Se, por algum motivo, não houver viabilidade para a realização online, o supervisor poderá recorrer à versão para impressão em suporte papel, disponibilizada em formato pdf que, ao ser solicitada para organização@torneiojrobotica.com.br , será remetida para o e-mail solicitante (inscrito no Sistema Gaia) no início do dia de realização.

1- O ENATER pode ser realizado impresso, durante o dia 13/08, se, por algum motivo, a escola não puder realizá-la online. Nesse caso, o supervisor já deverá estar inscrito no Sistema Gaia. 
2- O ENATER poderá ser realizada por alunos ainda não inscritos, contanto que o professor os inscreva até 16/08.

Atenciosamente,

Delegado Municipal - Alan Paiva

terça-feira, 17 de julho de 2012

Uso de switch e break na leitura de sensores de robô de sumo

Abaixo exemplo proposto por Robson Machado - www.eaduino.com.br que ainda não testamos mas, demonstra uma aplicação dos comandos switch e break. A principal dúvida seria nos cases - como testá-los. Uma aplicação deste código fonte seria a leitura de sensores com intervalos, por exemplo, para medir a quantidade de água de um reservatório e tomar ações a partir disso - Projeto Educasaen.


/* Código desenvolvido por Robson Machado - www.eaduino.com.br a partir de questionamento
feito pela nossa equipe, adaptado para a equipe Orion e Fenix.
*/
int led = 6;
int led1 = 7;
int s1 = 0;
int s2 = 1;
int var2=1;
int var = 0;
void setup () {
  pinMode (led, OUTPUT);
  pinMode (led1, OUTPUT);
  pinMode (s1, INPUT);
  pinMode (s2, INPUT);
}
void loop () {
 var=analogRead (s1);//leitura do sensor de linha da frente
switch (var) {
case 1:
digitalWrite (led, HIGH);//inserir comando de movimento do motor
break;
case 2: // se sensor 1 sem sinal proceder a leitura dos sensores laterais
var2=analogRead (s2); // leitura do sensor 2 foi realizada
digitalWrite (led1, HIGH); //testar a variavel 2 se positivo, ordenar movimento
break;
default:// caso negativo, ordenar a frente
digitalWrite (led, HIGH);
delay (1000);
digitalWrite (led1, HIGH);
delay (1000);
digitalWrite (led, LOW);
digitalWrite (led1, LOW);
delay (10000);
}
}

Controle de Motor Usando Ponte H

06/03/2013
Começamos a desenvolver pontes H com TIP 110/115 para uso nos robôs que tem motores de escova. A vantagem desta ponte é a corrente que suporta, chegando a 4A.

Fotos da montagem:



17/07/2012
No projeto do Grupo Orion (Elza Facca) e do grupo Fenix (Frei Dagoberto) estamos pensando em trabalhar com servo motores de parabólica, adaptados para rotação contínua (veja exemplo aqui - http://www.roboticasimples.com/artigos.php?acao=16), usando o arduino 2009 controlando os motores por meio de pontes H.




Na ponte H, estudamos o TIP120, conforme esquema acima e, para o arduino controlar os motores, vamos utilizar o seguinte código fonte:

// Comando de motores usando ponte H
// —————————————————————————  Motores
int motor_esquerdo[] = {2, 3}; //pinos do motor1
int motor_direito[] = {7, 8}; //pinos do motor2
// ————————————————————————— Setup
void setup() {
Serial.begin(9600);
// Seleciona motores
int i;
for(i = 0; i < 2; i++){
pinMode(motor_esquerdo[i], OUTPUT);
pinMode(motor_direito[i], OUTPUT);
}
}
// ————————————————————————— Loop
void loop() {
motor_frente();
delay(1000);
//mudança de sentido
motor_parar();
motor_re();
delay(1000);
//mudança de sentido
motor_parar();
vire_esquerda();
delay(1000);
//mudança de sentido
motor_parar();
vire_direita();
delay(1000);
//mudança de sentido
motor_parar();
motor_parar();
delay(1000);
//mudança de sentido
motor_parar();
}
// ————————————————————————— Drive do motor: coordena as funções de parada, frente, direita e esquerda
void motor_parar(){
digitalWrite(motor_esquerdo[0], LOW);
digitalWrite(motor_esquerdo[1], LOW);
digitalWrite(motor_direito[0], LOW);
digitalWrite(motor_direito[1], LOW);
delay(25);
}
void motor_frente(){
digitalWrite(motor_esquerdo[0], HIGH);
digitalWrite(motor_esquerdo[1], LOW);
digitalWrite(motor_direito[0], HIGH);
digitalWrite(motor_direito[1], LOW);
}
void motor_re(){
digitalWrite(motor_esquerdo[0], LOW);
digitalWrite(motor_esquerdo[1], HIGH);
digitalWrite(motor_direito[0], LOW);
digitalWrite(motor_direito[1], HIGH);
}
void vire_esquerda(){
digitalWrite(motor_esquerdo[0], LOW);
digitalWrite(motor_esquerdo[1], HIGH);
digitalWrite(motor_direito[0], HIGH);
digitalWrite(motor_direito[1], LOW);
}
void vire_direita(){
digitalWrite(motor_esquerdo[0], HIGH);
digitalWrite(motor_esquerdo[1], LOW);
digitalWrite(motor_direito[0], LOW);
digitalWrite(motor_direito[1], HIGH);
}

fonte: Não lembro mais, sorry!!!

Este código fonte foi revisado pela equipe EADUINO - Robson Machado (www.eaduino.com.br), valeu gente pela ajuda.

Em breve, postaremos os vídeos do trabalho em funcionamento.