Resultados da busca - %E3%80%90%E2%94%83%E5%B8%82%E5%9C%BA%E9%83%A82%E2%92%8F7%E2%92%8F01705%5B%E6%89%A3%5D%E3%80%91%E3%80%91%E6%81%92%E8%BE%BE%E5%BD%A9%E7%A5%A8%E5%B9%B3%E5%8F%B0%E5%AE%98%E6%96%B9%E7%BD%91%E7%AB%99
um mouse, e não é detectável em jogos online nem muda os drivers, com um simples Arduíno mini é possível reproduzir o projeto em um mouse comum.
Componentes necessários(para teste):
1x Arduino uno ou mini...
1x protoboard
x Jumpers
5x transistores PNP BC558 //para fazer o teste correto quando inseri-lo ao mouse
5x resistores de 1k //para base dos transistores
5x resistores de 220r //para os leds
5x Leds //para testar os terminais que vão para a placa do mouse
6 Push-Button //para acionaras funçoes
Componentes necessários(para uso no dispositivo):
1x Arduino mini
1x mouse comum
5x transistores PNP BC558 //para ativar o sinal do mouse conforme o Arduíno ordenar
5x resistores de 1k //para base dos transistores
Bom como perceberam,apesar de eu não ter tirado muitas fotos (pretendo corrigir isso ao final do projeto) o esquema de ligaçao é simples, pois o circuito foi adaptado para funcionar como push-buttons visto que o mouse para comandar suas funções utiliza o GND para acionamento dos botoes então é ae que entra o BC558, sabendo que o Arduíno só tem saída + em suas portas era necessário um transistor PNP para converter o sinal em GND.
Assim ligamos as saídas do Arduíno nos resistores de 1k que por sua vez são ligados a base do transistor, tendo seus coletores ligados ao GND os pinos Emissores serão ligados as trilhas do circuito que receberia o sinal dos botoes, o Arduíno mini sera alimentado pela própria usb do dispositivo e as trilhas originais dos botoes devem ser cortadas./*para mais proteção recomenda-se o uso de um regulador de tensão 5v , o mini pode ser programado com um Arduíno uno ou placa usb-serial*/
Uma das vantagens é que o código é simples e de fácil entendimento para criação de novos perfis de macro, então crie seu próprio macro!
vamos ao sketch:
//projeto Macro mouse genericoint botDIR=13;//entrada botao direito int botdir=12;//saida transistor PNP BC558 direitaint botESQ=11;//entrdada botao esquerdo int botesq=10;//saida transistor PNP BC558 esquerdaint botCTR=9;//entrada botao central(roda do mouse) int botctr=8;//saida botao transistor PNP BC558 central(roda do mouse)int bot1LTR=7;//entrada 1 botao lateral int botltr1=6;//saida de transistor PNP BC558 botao lateralint bot2LTR=5;//entrada 2 botao lateral int botltr2=4;//saida botao transistor PNP BC558 lateralint botMODE=3;//entrada botao Mode gamming (CPI) int mode=0;//variavel inicial do menu//tempo de precionamento#define t_500 delay(500);#define t_300 delay(300);#define t_200 delay(200);#define t_100 delay(100);//ativa e desativa os botoes//valores de ligado e desligado foram invertidos por causa do transistor#define ligEsq digitalWrite(botesq, LOW); ;//liga o esquerdo #define desEsq digitalWrite(botesq, HIGH);//desliga----^#define ligDir digitalWrite(botdir, LOW); ;//liga o direito #define desDir digitalWrite(botdir, HIGH); //desliga--^#define ligLtr1 digitalWrite(botltr1, LOW); ;//liga o lateral 1 #define desLtr1 digitalWrite(botltr1, HIGH);//desliga---^#define ligLtr2 digitalWrite(botltr2, LOW); ;//liga o lateral 2 #define desLtr2 digitalWrite(botltr2, HIGH);//desliga--^#define ligCtr digitalWrite(botctr, LOW); ;//liga o central #define desCtr digitalWrite(botctr, HIGH);//desliga--^//Principais Skills do Macro-------------------------------------------------------------------------------------------------------------------------------------------------------------#define Pressed_Dir int botDIR1 =digitalRead(botDIR); if(botDIR1 == LOW){ligDir;}else{desDir;}//precionamento direito normal #define Pressed_Esq int botESQ1 =digitalRead(botESQ); if(botESQ1 == LOW){ligEsq;}else{desEsq;}//precionamento esquerdo normal#define Pressed_1Ltr int botLTR1 =digitalRead(bot1LTR); if(botLTR1 == LOW){ligLtr1;}else{desLtr1;}//precionamento lateral 1 normal#define Pressed_2Ltr int botLTR2 =digitalRead(bot2LTR); if(botLTR2 == LOW){ligLtr2;}else{desLtr2;}//precionamento lateral 2 normal#define Pressed_Ctr int botCTR1 =digitalRead(botCTR); if(botCTR1 == LOW){ligCtr;}else{desCtr;}//precionamento roda do mouse normal#define Pressed_Esq_3kill int botESQ1 =digitalRead(botESQ); if(botESQ1 == LOW){for(int ct=0; ct < 3; ct++){ligEsq; t_200; desEsq; t_100;}}else{desEsq;}//triplo precionamento direito#define Pressed_Ctr_3 int botCTR1 =digitalRead(botCTR); if(botCTR1 == LOW){for(int ct=0; ct < 3; ct++){ligCtr; t_200; desCtr; t_100;}}else{desCtr;}//triplo precionamento roda do mouse#define Pressed_Esq_Scope int botESQ1 =digitalRead(botESQ); if(botESQ1 == LOW){ligDir; t_300; ligEsq; t_300; desEsq; desDir;}//scope "direita">>"esuqerda"|"direita"#define Pressed_Mode int botMODE1 =digitalRead(botMODE); if(botMODE1 == LOW){mode++; t_500;}if(mode == 5){mode=0;}//seleciona o n max de perfis que atualmente é 6//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^void setup(){//PULLUP PERMITE LIGAR UM BOTAO AO TERRA DIRETAMENTE//Serial.begin(9600); pinMode(botDIR,INPUT_PULLUP);//Entrada direita pinMode(botdir,OUTPUT);//saida direita pinMode(botESQ,INPUT_PULLUP);//Entrada esquerda pinMode(botesq,OUTPUT);//saida esquerda pinMode(botCTR,INPUT_PULLUP); //Entrada do botao da roda do mouse pinMode(botctr,OUTPUT);//saida do botao da roda do mouse pinMode(bot1LTR,INPUT_PULLUP);//Entrada do botao lateral 1 pinMode(botltr1,OUTPUT);//saida botao lateral 1 pinMode(bot2LTR,INPUT_PULLUP);// Entrada do botao lateral 2 pinMode(botltr2,OUTPUT);//saida botao lateral 2 pinMode(botMODE,INPUT_PULLUP);// Entrada do botao CPI do mouse}//fim do void setupvoid loop(){Pressed_Mode;//perfil normalif(mode == 0){//Serial.println("normal"); Pressed_Dir; Pressed_Esq; Pressed_1Ltr; Pressed_2Ltr; Pressed_Ctr; }//perfil sniperif(mode == 1){//Serial.println("sniper"); Pressed_Esq_Scope; Pressed_Dir; Pressed_1Ltr; Pressed_2Ltr; Pressed_Ctr; }//perfil 3balas por vezif(mode == 2){//Serial.println("3balas"); Pressed_Dir; Pressed_Esq_3kill; Pressed_1Ltr; Pressed_2Ltr; Pressed_Ctr; }//perfil baionetaif(mode == 3){//Serial.println("baioneta"); Pressed_Dir; Pressed_Esq; Pressed_Ctr_3; Pressed_1Ltr; Pressed_2Ltr; }//perfil misto scope+baionetaif(mode == 4){// Serial.println("scope e baioneta"); Pressed_Esq_Scope; Pressed_Dir; Pressed_Ctr_3; Pressed_1Ltr; Pressed_2Ltr; }}//fim do void loop
Em anexo segue fotos de esquema e sketch, bom projeto!…
nicos de IOT, sendo que desenvolvo meus projetos só para conhecer a tecnologia de software e hardware por trás das coisas.
Há cerca de 4 anos pensei em desenvolver um robô que faz um mapeamento de ambiente, podendo ser um labirinto, achando uma saída ou ponto pré-determinado.
O robô foi construído na plataforma Tamiya, chassi para o veículo com esteira e caixa de engrenagem com motor duplo. A placa foi utilizada no Garagino VER 1 Básico, com um Dual Motor Garagino, ambos descontinuados.
Um dos módulos é o sensor de obstáculos. Utilizei o sensor ultrassônico ultra-sônico HC-SR04 movimentado por um Micro servo motor SG90.
Para fazer uma comunicação do robô com o celular, use o Módulo Bluetooth RS232 - HC-06.
Desenvolvi um Sketch Arduino para movimentar o radar e ler o sensor. Esse Sketch comunica com um App, desenvolvido para o App Inventor.
1- Montagem Do Hardware
Material:
1 - Protoboard;
1 - Arduino Uno ou genérico;
1 - Sensor ultra-sônico HC-SR04;
2 - Resistores de 10kΩ;
1 - Micro servo motor SG90;
1 - Módulo Bluetooth RS232 - HC06.
As portas TRIG e ECHO do SR04 vão conectadas os pinos A3 e A2 do Arduino, respectivamente.
As portas TX e RX do HC06 se conectam nos pinos D3 e D2 do Arduino, respectivamente.
Entre as portas D3 e RX existem 2 Resistores de 10kΩ ligados entre si e no pino GND do Arduino.
O SG90, se liga ao pino D9 do Arduino.
As portas GND e VCC são conectadas aos seus respectivos pontos.
2- Código Arduino
Agora vamos programar o Arduino de acordo com o fluxo abaixo.
Também segue uma cópia do arquivo ".ino" em anexo.
1º - Inclusão das bibliotecas;
2º - Definições dos pinos de acordo com a descrição da etapa anterior.
3º - Declaração de variáveis para enviar dados via bluetooth.
4º - Declaração de variáveis para o sensor de distancia.
5º - Declaração de variáveis do calculo de distância.
6º - Setup, definindo a saída para o Bluetooth e definindo o pino do servo motor.
7º - No Loop, colocar o servo para frente; fazer a leitura do bluetooth; receber um comando definido no App e ativa o sensor; parar o sensor.
8º - Criar um Void() para a leitura do sensor.
Esse Void() faz a varredura do sensor, dos ângulos 10º ao 170º, colhendo as distancias; estabelece 45 cm como a maior distancia a ser lida; organiza as variáveis diferentes para enviar para o App; gera as saídas formatadas, interpolando variáveis a uma string de formatação; especifica a utilização de buffer para armazenamento; faz a leitura a cada 50 milissegundos, mesma do temporizador do App.
9º - Criar um Void() para parar o sensor.
3 - Código App Inventor
Segue o arquivo ".aia" do App Inventor para análise, alterações e utilização.
No App Inventor vamos primeiro fazer o designer da tela.
Observações importantes:
- Na paleta Desenho e Animação, vamos utilizar a Pintura, com as seguintes propriedades: Cor De Fundo, preto; Imagem De Fundo, nenhum; Tamanho Da Fonte, 14.0; Altura, 150 pixels; Largura, 300 pixels; Largura Da Linha, 2.0; Cor De Pintura, Verde; Alinhamento Do Texto, centro : 1.
- Na paleta Sensores, vamos utilizar o Temporizador, com as propriedades de Disparos Contínuos, marcado; Ativado, marcado e Intervalo, 50 (que significa 50 milissegundos, em acordo com o Sketch do Arduino)
Nos blocos, temos 6 blocos com o controle "Quando" e 4 blocos com declaração de variáveis. 1 bloco trata da tela inicial; 2 blocos controlam a lista de pareados do bluetooth; 1 bloco cuida do temporizador; 1 bloco do botão RADAR e 1 bloco do botão PARAR O RADAR.
A maior dificuldade encontrada foi no desenho das linhas do radar, que deveriam seguir o sensor e apresentar as distâncias.
O robô ainda está em desenvolvimento.
Publicarei demais módulos a medida que forem sendo desenvolvidos.
Quem tiver interesse em participar nesse projeto estou à disposição para sugestões e compartilhamento de informações no desenvolvimento.
Abraços fraternos…
s o próprio EMI gerado pelo circuito, é mais de 90% provocado pelo overshoot (intensidade e frequência). E certamente esse EMI será um imenso problema em equipamentos comerciais (se for muito alto, nem será aprovado em ensaios de certificação).
Então agora podemos abrir o jogo um pouco mais, assim colaborando com outros que venham aqui no LDG procurando informação relacionada.
Vamos resumir as coisas assim:
1) o chaveamento da corrente em L2, gera impulsos de tensão que tendem a ser os impulsos unitários, porém estes são do mundo real (tem amplitude limitada e a largura do pulso não é zero). Estes impulsos nada mais são portanto, do que "pacotes" de energia que que são enfiados pela guela do capacitor na saída do seu Conversor DC/DC. Cada novo impulso acrescenta um novo pacote de carga "dQ" ao Capacitor de saída, o que por sua vez se traduz num delta de tensão. Sem uma carga resistiva na saída, com o passar do tempo, a tensão sobre esse Capacitor tenderá a alcançar praticamente quase o mesmo valor do impulso, e isto ocorre porque simplesmente estamos pegando um "pacote" de carga "dQ", e jogando em cima de um valor de capacitância de saída muito alto (no seu caso, C4 de 2000uF), e pela equação V = Q/C, pode-se calcular não somente o degrau de tensão dV, mas a própria tensão final sobre o Capacitor após cada novo impulso.
2) mas ao termos uma carga resistiva na saída, parte de cada "dQ" é também usado para alimentar esta carga resistiva, o que implica que esta carga resistiva atua justamente como o "outro lado do cabo de guerra", e assim "trabalha" no sentido de reduzir a tensão sobre o Capacitor de saída. Ao final das contas, espera-se que a taxa de impulsos por segundo, seja suficiente para equilibrar esse cabo de guerra, fazendo com que a tensão sobre o Capacitor se estabilize em torno de um valor médio (na realidade, ela acaba oscilando em torno do valor médio, e este é o ripple real na saída). A taxa de impulsos é a própria frequência de chaveamento, e ela acaba por bombear impulsos de "dQ" para o Capacitor de saída. Maior taxa (frequência), compensação mais rápida. Menor taxa, compensação mais lenta. Um algorítimo de controle de malha fechada, então nada mais faz do que ajustar essa taxa para que a saída tenha o comportamento de tensão esperado: quase constante para uma tensão DC, ou em "arco" crescente ou decrescente para uma saída senoidal. Claro que neste último caso, você poderá variar a própria tensão de entrada (como vc mencionou que já o fez), e assim terá também uma variável a mais na sua equação, que será a intensidade de cada pacote de energia "dQ", e assim tendo um maior controle sob o comportamento da tensão de saída.
3) o fato de ser Buck, Boost, é apenas o resultado da manipulação da intensidade e frequência dos pacotes "dQ", já que estes acrescentam energia ao Capacitor de saída, determinando a tensão sobre este capacitor, ou seja, simplesmente um resultado da conversão V = Q/C, considerando que parte da energia acumulada no Capacitor de saída está sendo drenada por uma carga resistiva (formando o "cabo de guerra" entre consumo e "bombeamento" de energia).
4) e o fato de ser saída positiva ou negativa, é apenas a configuração de como vc direciona os impulsos "dQ" para o Capacitor de saída, ou seja: determinado pela polaridade do Diodo na saída (no seu circuito, D2), que é o elemento chave nisto. Obviamente a polaridade do Capacitor deverá estar de acordo com a tensão resultante desse direcionamento.
5) as diversas configurações mostradas no "slyu036" da Texas, nada mais são do que uma exploração das possíveis variações do que foi descrito acima, inclusive recombinando os circuitos e aplicando o controle adequado ao chaveamento para se obter as características de conversão DC/DC desejadas.
6) uma pequena parte do "dQ" do impulso, acaba injetando energia em um "inesperado" Circuito Tanque LC, composto pelo próprio Indutor do chaveamento de corrente e pela capacitância parasítica existente ali, resultando na oscilação amortecida de alta frequência determinada por Freq = 1/(2*Pi*raiz(LC)). Observe que qualquer chaveamento da corrente do Indutor, irá provocar o impulso de tensão, devido ao Ldi/dt, e havendo alguma capacitância parasítica formando um Circuito Tanque LC, certamente existirá o overshoot senoidal amortecido, na frequencia natural do tanque LC.
7) sempre haverá dois overshoots, pois o indutor é chaveado duas vezes em cada ciclo do seu PWM. Em um dos edges do PWM, a capacitância parasítica do Diodo formará com o Indutor, o circuito tanque LC, resultando em um overshoot. No edge seguinte, será a capacitância parasítica entre Gate e Dreno do MOSFET que se juntará ao Indutor para formar o tanque LC, e um overshoot com outra frequencia e intensidade ocorrerá.
8) e finalmente: como capacitores também são elementos de acoplamento de tensão, uma capacitância parasítica entre dois pontos, acoplará o overshoot no outro nó correspondente ao outro lado desse capacitor. É por isso Dário, que no seu próprio sinal PWM também acaba aparecendo o overshoot (mesma frequência, mas com outra intensidade, que pode ser calculada por um divisor de tensão com impedâncias imaginárias).
Agora sobre o tratamento:
1) observe que estes circuitos procuram usar diodos do tipo "Schottky", pois estes além de serem rápidos tem uma menor "capacitância de barreira" que os diodos "PN" convencionais. Os "Schottky" também tem uma menor resistência de corpo (BULK), o que diminui as perdas por efeito Joule. Observe que nos APNs, vc sempre verá diodos "Schottky" sendo usados (naquela plaquinha da China, também).
2) observe qual a capacitância parasítica intrínseca entre Dreno e Gate do MOSFET, e claro ela deve ser a menor possível, e se deve tomar o cuidado para não acrescentar circuitos ali que causem aumento significativo dessa capacitância entre Dreno e Gate. Observe também que devido ao proprio liga/desliga do MOSFET, capacitâncias parasíticas entre Dreno e Source também podem injetar um "dQ" no Dreno, causando também um overshoot. Logo, a chave aqui, é escolher MOSFETs que tenham sido projetados para chaveamento em circuitos conversores DC/DC de alta frequência, pois certamente suas capacitâncias terão valores menores. Usar MOSFETs originalmente projetados apenas para um ON/OFF convencional, poderá ser um tiro no pé.
3) o Capacitor Eletrolítico de Alumínio de alto valor usado como parte essencial do conversor DC/DC, não irá amenizar o overshoot na saída, porque este tipo de Capacitor tem também uma alta indutância equivalente (ESI), e portanto não filtra a alta frequência do overshoot. Para esta tarefa, sempre se deve usar em paralelo com o Eletrolítico de Alumínio (no seu caso o "C4" de 2000uF), ou um Capacitor de Tântalo ou um de Cerâmico, os quais tem uma baixa indutância equivalente. Veja que nos datasheets desses conversores DC/DC integrados, sempre é especificado o acréscimo de um Capacitor de Tântalo ou do tipo Cerâmico, justamente pelo motivo delineado. Usar combinação de Tântalo e Cerâmico, também é uma ótima alternativa, principalmente em termos de custo e eficiência.
4) usar técnicas pontuais caso seja realmente necessário, como os "snubers" do artigo que vc citou (o do Marcin Walczak). Mas antes disso, deve-se obrigatoriamente aplicar as técnicas convencionais citadas acima (todas devem ser usadas, sem exceção). Caso o overshoot ainda resulte ser acima do mínimo aceitável para sua aplicação, então parte-se para aplicar técnicas pontuais e especializadas.
Fico por aqui, pois um pouco mais disso vai me dar overshoot.
Mas claro, se houver algo mais que eu possa ajudar e esteja ao meu alcance, vamos em frente.
Abrçs,
Elcids…
Adicionado por Elcids Chagas ao 5:46 em 14 março 2019
mosa “luzinha azul”
No mundo do IoT e da automação em geral, é muito comum deparar-nos com controles remotos via celulares utilizando tecnologia BT. Isso é devido a 3 componentes básicos mas muito importantes:
Plataforma de desenvolvimento para Android
Módulos BT baratos e acessíveis (Como por exemplo o HC-06)
E claro, o velho e bom Arduino....
Neste tutorial, vou desenvolver algumas idéias de como controlar as saídas de um Arduíno através de um celular de maneira a mover um Robot, acionar lâmpadas em uma casa, etc.
No mercado é comum encontrar módulos de BT 3.0 “Master-Slave” como o HC-05 e “Slaves” como o HC-06. Já mais recentemente, apareceram os HC-08 e HC-10 que trabalham com tecnologia BT 4.0 ou BLE (“Bluetooth Low Energy”). Os módulos BLE são os únicos que podem ser conectados a um Iphone, pois infelizmente a Apple não fornece suporte a ao BT 3.0.
Para os projetos discutidos aqui, usarei um HC-06 que é bem popular e barato (Bye, bye, Iphone, vamos de Android!). O Módulo é alimentado com 5V o que faz com que ele seja facilmente conectado a um Arduino UNO por exemplo, para receber e transmitir informações a outros dispositivos como um PC ou um telefone celular. Seus pinos de transmissão e recepção podem ser conectados diretamente ao UNO, não havendo a necessidade de se utilizar divisores de tensão como vimos no caso do ESP8266.
Na prática, o HC-06 deve ser ligado diretamente aos pinos 0 e 1 do Arduino (Serial):
HC06-Tx ao Arduino pin 0 (Rx)
HC06-Rx ao Arduino pin 1 (Tx)
Ao se usar a entrada serial por HW do UNO é muito importante lembrar-se que o HC-06 não pode estar fisicamente conectado aos pinos 0 e 1 durante a carga do programa, isso porque o USB também usa essa mesma serial. Uma maneira simples de se contornar esse probleminha (se seu projeto não utiliza muitos GPIOs do UNO) é usar uma porta serial por SW através da library SoftwareSerial (a mesma que usamos no caso do ESP8266). Em nosso caso aqui, usaremos os pinos 10 e 11 do UNO (Tx, Rx respectivamente).
O passo seguinte será escrever um codigo bem simples para se poder testar, programar e inicializar o HC-o6:
Para iniciar, incluir a Library Software Serial, definindo a variável “BT” como a nova porta serial.
#include <SoftwareSerial.h> SoftwareSerial BT(10, 11); // RX, TX String command = ""; // Stores response of bluetooth device
void setup() { Serial.begin(9600); Serial.println("Type AT commands!"); BT.begin(9600); // HC-06 usually default baud-rate }
Em seguida vem o corpo principal do código que simplesmente espera por dados vindos do BT e uma vez que eles chegem, os mesmos são escritos no Serial Monitor. Da mesma maneira, se podem enviar comandos AT desde o monitor serial até o módulo HC-06.
void loop() { if (BT.available()) // Read device output if available. { while(BT.available()) // While there is more to be read, keep reading. { delay(10); //Delay added to make thing stable char c = BT.read(); //Conduct a serial read command += c; //build the string. } Serial.println(command); command = ""; // No repeats } if (Serial.available()) { delay(10); // The DELAY! ********** VERY IMPORTANT ******* BT.write(Serial.read()); } }
Uma vez carregado o programa, faça alguns testes básicos. Por exemplo:,
Envie “AT“, o módulo deverá responder “OK“.
Pergunte a versão do Firmware: “AT+VERSION”, o módulo deverá responser, por exemplo: “linvorV1.8“.
Com o HC-06 é possível definir um nome para o módulo por exemplo: “AT+NAMEMJRoBot_BT_HC06“. Mas diferente de outros módulos, voce não conseguirá saber qual é o nome que está definido para o módulo. Ao se enviar o comando anterior, o HC-06 responderá simplesmente: “OKsetname”.
Em geral, o HC-o6 vem de fábrica com o password (ou PIN): 1234. Voce poderá definir um novo com o comando AT: AT+PINxxxx onde ‘xxxx‘ serão 4 números.
OK! Módulo conectado ao UNO e funcionando. Hora de lançar mão do velho e bom celular Android!!!
Existem muitas apps na loja da Google que podem ser utilizadas. Vou sugerir duas delas, por serem as que usarei em meus tutoriais. Essas apps foram desenvolvidas por mim utilizando o MIT Application2 tool (ver projeto aqui) e estão disponíveis sem custo na loja da Google:
MJRoBoT II BT Control
MJRoBot BT Digital Analog Voice Control
O App MJR0Bot II foi desenvolvido para comandar Robots. Ele basicamente envia um caracter para cada comando de direção, modos AUTO/MANUAL, velocidade + e velocidade-. Alem de permitir o envio de mensagens em modo texto.
O App. MJRoBot Digital Analog Voice Control, envia comandos para acionamento digitais (ligar/desligar) tanto por botões como por voz e comandos numéricos para controle de PWMs (0-255).
Faça o Download de qualquer uma das duas Apps, vá ao set-up do celular e procure o modulo BT fazendo a conexão (entre com o PIN 1234 ou algum outro definido por você). Isso deverá ser feito uma única vez, pois o celular guardará os dados de conexão. Uma vez que o celular e o HC-06 estão conversando, é só usar as APPs.
A partir da segunda vez, ao lançar-se a app, o modulo BT estará desconectado.
Acione o botão de BT, para que o app informe dos modulos disponíveis:
Selecione o nome do módulo (No caso é esse com o HC-06 ao final).
O App então mostrará “CONNECTED”, informando que está “pared” com o HC-06
A partir daí, é só ir acionando os botões do APP e observar no Monitor Serial, o que é que o APP está enviando.
Por exemplo, acionando “ON” e “OFF” sequencialmente para os 4 devices, no caso da APP MJRoBot Digital Analog Voice Control, o resultado seria:
dev1on dev1off dev2on dev2off dev3on dev3off dev4on dev4off
Agora que já temos um App para o Android e sabemos como funciona um modulo BT, vamos colocar a mão na massa e criar algo de util!
Controlando as saídas do Arduino.
Vamos construir o circuito abaixo:
A idéia será usar o App MJRoBot Digi/Ana/Voice Ctrl para acender e apagar os LEDS e também controlar a intensidade dos mesmos usando PWM.
Estaremos relacionando:
Device 1: "dev1on/dev1off" ==> LED Red ==> Pin 3 do UNO
Device 2: "dev2on/dev2off" ==> LED Yellow ==> Pin 5 do UNO
Device 3: "dev3on/dev3off" ==> LED Green==> Pin 6 do UNO
Device 4: "dev4on/dev4off" ==> LED Blue==> Pin 9 do UNO
Ou seja, ao acionar o botão “ON” relacionado ao “Device 1”, a mensagem de texto “dev1on”será enviada ao Arduino. Ao receber essa mensagem, o LED vermelho deverá acender e assim por diante.
Observe que os 4 pinos são pinos com capacidade de gerar PWM. Isso é importante para a utilização dos “sliders” da App, que enviarão valores para controlar a intensidade dos LEDs via PWM:
Dev A0: "r/ 0-255" ==> LED Red ==> Pin 3 do UNO
Dev A1: "y/ 0-255" ==> LED Yellow ==> Pin 5 do UNO
Dev A2: "g/ 0-255" ==> LED Green==> Pin 6 do UNO
Dev A3: "b/ 0-255" ==> LED Blue==> Pin 9do UNO
No caso dos controles deslizantes (“sliders”), antes dos valores para controle do PWM (0 a 255), um caracter será enviado para que o Arduino saiba de que “slider” estará chegando o comando.
O Código:
Setup inicial:
#include <SoftwareSerial.h>
SoftwareSerial BT(10, 11); //TX, RX respectively String device;
const int dev1 = 3; //PWM const int dev2 = 5; //PWM const int dev3 = 6; //PWM const int dev4 = 9; //PWM
void setup() { BT.begin(9600); Serial.begin(9600);
pinMode(dev1, OUTPUT); pinMode(dev2, OUTPUT); pinMode(dev3, OUTPUT); pinMode(dev4, OUTPUT); }
Podemos dividir a parte principal do programa em 4 blocos:
Espera dos comandos BT e construção da variável “device”
Acionamento dos LEDS a partir dos botões
Acionamento dos LEDS a partir de comandos de voz
Controle do intensidade dos LEDs via Sliders
void loop() { while (BT.available()) //Check if there is an available byte to read { delay(10); //Delay added to make thing stable char c = BT.read(); //Conduct a serial read device += c; //build the string. } if (device.length() > 0) { Serial.println(device); // Button control: if (device == "dev1on") {digitalWrite(dev1, HIGH);} else if (device == "dev1off") {digitalWrite(dev1, LOW);} else if (device == "dev2on") {digitalWrite(dev2, HIGH);} else if (device == "dev2off") {digitalWrite(dev2, LOW);} else if (device == "dev3on") {digitalWrite(dev3, HIGH);} else if (device == "dev3off") {digitalWrite(dev3, LOW);} else if (device == "dev4on") {digitalWrite(dev4, HIGH);} else if (device == "dev4off") {digitalWrite(dev4, LOW);}
// Voice control: else if (device == "ligar um" || device == "Ligar 1") {digitalWrite(dev1, HIGH);} else if (device == "desligar um" || device == "desligar 1") {digitalWrite(dev1, LOW);} else if (device == "ligar som" || device == "Ligar som") {digitalWrite(dev2, HIGH);} else if (device == "desligar som" || device == "Desligar som") {digitalWrite(dev2, LOW);} else if (device == "ligar TV" || device == "Ligar TV") {digitalWrite(dev3, HIGH);} else if (device == "desligar TV" || device == "Desligar TV") {digitalWrite(dev3, LOW);} else if (device == "ligar quarto" || device == "Ligar quarto") {digitalWrite(dev4, HIGH);} else if (device == "desligar quarto" || device == "Desligar quarto") {digitalWrite(dev4, LOW);}
// Slider control: char colour = device[0]; int value = device[2]; Serial.print(" "); Serial.println(value); if ( colour == 'r') { analogWrite(dev1, value); // use value to set PWM for LED brightness } if ( colour == 'y') { analogWrite(dev2, value); // use value to set PWM for LED brightness } if ( colour == 'g') { analogWrite(dev3, value); // use value to set PWM for LED brightness } if ( colour == 'b') { analogWrite(dev4, value); } device=""; //Reset the variable } }
Deixo aqui o link para os códigos usados neste tutorial:
Link para os códigos Arduino
No vídeo abaixo, uma demonstração da porção programa acima (botões & Slider):
Vídeo demo comando por botões e Slider
O controle de dispositivos IoT por voz é uma tendência nos dias de hoje. Conseguir este tipo de controle com o conjunto Arduino/HC-06/Android é extremamente simples. Os dispositivos Android já possuem essa característica “de fábrica”. No App que desenvolvi, apenas acrescentei um botão que faz com que o Android “escute” um comando e o envie em formato texto para o Arduino. O codigo se encarrega de “ler” a string que chega.
Em vermelho, ressalto no código alguns possíveis comandos de voz. Ao receber por “Ligar TV” por exemplo, o LED verde (correspondente ao device 3) acenderá (em vez do LED podíamos ter uma relé que ligaria a TV).
No vídeo abaixo, uma pequena demonstração do controle por voz:
Vídeo demo de comandos por voz.
Bom, acredito que já é possível ver o enorme potencial do controle de “coisas” usando BT/Android/Arduino. Em meus próximos posts estarei desenvolvendo Robots que poderão ser controlados remotamente como vimos aqui.
Para mais tutoriais, demos, vídeos, etc. visite meu blog:
MJRoBot.org
Um abraço e até mais!
…
Adicionado por Marcelo Rovai ao 19:45 em 31 janeiro 2016