|
|
| (127 revisões intermediárias por 2 usuários não estão sendo mostradas) |
| Linha 1: |
Linha 1: |
| =Arduíno= | | =Arduíno= |
|
| |
|
| ;Descrição: O Arduino é um microcontrolador montado em uma plataforma de prototipagem eletrônica de hardware livre que pode ser utilizado em múltiplas aplicações. O Arduino é facilmente programável e pode ser utilizado para automação de dispositivos eletrônicos, acionamento de motorExemplo.jpges e leds, monitoramento de sensores, construção de protótipos de soluções tecnológicas e um mundo de possibilidades. | | ;Descrição: O Arduino é um microcontrolador montado em uma plataforma de prototipagem eletrônica de hardware livre que pode ser utilizado em múltiplas aplicações. O '''Arduino''' é facilmente programável através de uma '''interface de programação''' ('''IDE''') e pode ser utilizado para automação de dispositivos eletrônicos, acionamento de motores e leds, monitoramento de sensores, construção de protótipos de soluções tecnológicas e um mundo de possibilidades. |
|
| |
|
| ;Links e referências: | | ;Links e referências: |
| *[http://www.arduino.cc/ Site oficial do Arduíno] | | *[http://www.arduino.cc/ Site oficial do Arduíno] |
| *[http://www.arduino.cc/en/Reference/HomePage Arduíno Reference] | | **[https://www.arduino.cc/reference/pt/ Referência da Linguagem] |
| *[http://www.labdegaragem.com.br/wiki/index.php?title=Sobre_Arduino#Introdu.C3.A7.C3.A3o Wiki com exemplos de aplicação com Arduíno] | | **[https://www.arduino.cc/en/Tutorial/BuiltInExamples Exemplos prontos] |
| | **[https://www.arduino.cc/en/Tutorial/LibraryExamples Exemplos usando Bibliotecas] |
|
| |
|
| ;Instalação: Para instalação no Ubuntu 14.04:
| | ==Algumas placas Arduino== |
| sudo apt-get install arduino
| |
|
| |
|
| ==Placas Arduino==
| | ;Arduino UNO: |
| | [[Arquivo:PinosArduinoUno.png|300px]] |
|
| |
|
| ===Arduino UNO===
| | ;Arduino Micro: |
| [[Arquivo:PinosArduinoUno.png|400px]] | | [[Arquivo:PinosArduinoMicro.png|375px]] |
|
| |
|
| Referência em português sobre o hardware do [http://www.embarcados.com.br/arduino-uno/ Arduino UNO].
| | ;Arduino Mega: |
| | [[Arquivo:PinosArduinoMega.png|500px]] |
|
| |
|
| ===Arduino Micro=== | | ==Hardware do Arduíno UNO <ref>https://www.arduino.cc/en/Main/ArduinoBoardUno</ref>== |
| [[Arquivo:PinosArduinoMicro.png|500px]]
| | *Microcontrolador ATmega328P |
| | *Voltagem de operação 5V |
| | *Alimentação recomendada 7-12V |
| | *Entradas/saídas digitais 14 (6 podem ser saídas PWM) |
| | *Saídas PWM "analógicas" 6 |
| | *Entradas analógicas 6 |
| | *Corrente DC por pino 20 mA |
| | *Corrente DC pino 3.3V 50 mA |
| | *Memória Flash 32 KB |
| | *Memória SRAM 2 KB |
| | *Memória EEPROM 1 KB |
| | *Velocidade do Clock 16 MHz |
|
| |
|
| ===Arduino Mega=== | | ===Voltagens de alimentação=== |
| [[Arquivo:PinosArduinoMega.png|700px]] | | O Arduíno pode ser alimentado pelo '''cabo USB''' ou por '''fonte externa'''. |
| | |
| | A alimentação com '''fonte externa''' recomendada é 7-12V. |
| | |
| | ;Pinos de voltagem: |
| | *'''5V''' Tensão regulada de '''5V''' (independente de alimentado pelo cabo UBS ou fonte externa). |
| | *'''3,3V''' Tensão regulada de '''3,3V'''. |
| | *'''GND''' Pinos de '''terra'''. |
| | *'''V<sub>in</sub>''' Quando utilizado '''fonte externa''' a tensão da mesma pode ser obtida aqui. |
| | *'''IO<sub>ref</sub>''' Fornece a tensão de referência que o microcontrolador opera, por exemplo, o UNO opera com 5V, mas o DUE opera em 3,3V. |
| | |
| | ===Entradas e Saídas=== |
| | |
| | ;14 Entradas/Saídas Digitais: Operam com valores digitais '''LOW''' ('''0V''') e '''HIGH''' ('''5V'''). Fornecem corrente de até '''20 mA'''. Qualquer corrente solicitada acima de '''40 mA''' pode danificar o Arduíno. |
| | |
| | ;6 Entradas Analógicas: Nomeadas de '''A0''' até '''A5'''. Por default recebem '''valores analógicos entre 0V e 5V''' e convertem para digital com '''10 bits de resolução''' (valores de '''0''' a '''1023'''). |
| | :'''A<sub>ref</sub>''' Usada para mudar a referência para a '''conversão analógico-digital''', deve ser usada em conjunto com a função '''analogReference'''(). Por exemplo, se quisermos converter sinal analógico entre 0 e 1,5V, colocamos esta tensão em A<sub>ref</sub>. |
| | |
| | ;6 Saídas PWM: Identificadas pelo sinal '''~'''. Fornecem '''saídas analógicas''' através de '''pulsos PWM''' (''Pulse Width Modulation'') de '''8 bits''' (valores de '''0''' a '''255'''). |
| | :O sinal PWM é uma onda quadrada, com frequência constante, mas a fração de tempo em que o sinal é HIGH (5V) (''duty cycle'') pode variar entre 0 e 100%, fornecedo uma média de tensão variável na saída <ref>https://www.arduino.cc/en/Tutorial/SecretsOfArduinoPWM</ref>. |
| | [[Arquivo:PWM.gif]] |
| | |
| | ;Led pino 13: O pino 13 tem um '''led montado na placa'''. Quando o pino for HIGH o led acende, quando for LOW o led apaga. |
| | |
| | ;Serial 0 (RX) e 1 (TX): Os pinos 0 e 1 podem ser usados para '''transmitir (TX) e receber (RX) serialmente''' dados TTL. |
| | :Dados digitais '''TTL''' operam valores LOW (0V) e HIGH (5V). |
| | |
| | ;Interrupções externas: Os pinos 2 e 3 podem ser utilizados para dispararem '''interrupções externas''' com a função '''attachInterrupt()'''. |
|
| |
|
| ==Ambiente de desenvolvimento do Arduíno== | | ==Ambiente de desenvolvimento do Arduíno== |
| O ambiente de desenvolvimento de software do Arduíno usa uma linguagem de programação própria, baseada na '''linguagem C'''. | | O ambiente de desenvolvimento de software do Arduíno usa uma linguagem de programação própria, baseada na '''linguagem C'''. |
| | |
| | ;Instalação: Para instalação no Ubuntu 20.04: |
| | sudo apt update |
| | sudo apt install arduino |
|
| |
|
| Os programas fonte são identificados pela extensão <tt>'''.ino'''</tt>. | | Os programas fonte são identificados pela extensão <tt>'''.ino'''</tt>. |
| Linha 32: |
Linha 76: |
|
| |
|
| [[Image:ArduinoIDE.png | 400 px]] | | [[Image:ArduinoIDE.png | 400 px]] |
| | | <!-- |
| ===Ambiente de programação S4A (Scratch for Arduíno)=== | | ===Ambiente de programação S4A (Scratch for Arduíno)=== |
| Também é possível programar o Arduíno usando o ambiente de programação [http://s4a.cat/ '''S4A''' (Scratch for Arduino)], permite realizar a programação do Arduino utilizando as mesmas estruturas da linguagem [[Scratch]], o que facilita muito o trabalho de quem está iniciando no mundo da programação de computadores. | | Também é possível programar o Arduíno usando o ambiente de programação [http://s4a.cat/ '''S4A''' (Scratch for Arduino)], permite realizar a programação do Arduino utilizando as mesmas estruturas da linguagem [[Scratch]], o que facilita muito o trabalho de quem está iniciando no mundo da programação de computadores. |
| Linha 43: |
Linha 87: |
| ;Sensores virtuais no S4a: É possível criar [http://www.arduteka.com/2012/11/sensores-virtuales-en-s4a/ Sensores Virtuais] para o S4A a partir da Web. | | ;Sensores virtuais no S4a: É possível criar [http://www.arduteka.com/2012/11/sensores-virtuales-en-s4a/ Sensores Virtuais] para o S4A a partir da Web. |
|
| |
|
| ==Eletrônica para Arduíno== | | ===Ambiente de programação ArduBlock=== |
| | | O '''ArduBock''' é um ambiente de programação para o Arduíno que utiliza blocos, similares ao do Scratch, facilitando a construção de programas para quem está iniciando no mundo da programação. |
| ;Fundamentos e conceitos:
| |
| *[[Eletricidade Básica]]
| |
| *[[Resistores]]
| |
| *[[Corrente Contínua e Corrente Alternada]]
| |
| *[[Medidas elétricas]]
| |
| *[[Eletrônica | Eletrônica Básica]]
| |
| | |
| ;Sensores baseados em resistência variável para Arduíno: '''Sensores de luminosidade (LDR)''' e '''sensores de temperatura''' possuem um resistor variável em função da grandeza que estão medindo. Os mesmos podem ser configurados em uma estrutura baseada em um [http://200.17.101.9/wiki/index.php/Eletricidade_B%C3%A1sica#Divisor_de_Tens.C3.A3o '''divisor de tensão'''] para fornecer uma tensão variável ao '''Arduíno'''.
| |
| | |
| ;Acionamento de [http://200.17.101.9/wiki/index.php/Eletr%C3%B4nica#Leds leds] com Arduíno: O '''Arduíno''' fornece no máximo 40mA de corrente em cada um dos pinos de saída e tensão de 0V a 5V. Portanto, deve ser colocado um resistor em série com o led para limitar a corrente de saída do Arduíno e também a corrente máxima do led.
| |
| | |
| :[[Arquivo:FotoLed.jpg | 200px]]
| |
| | |
| ;[http://200.17.101.9/wiki/index.php/Eletr%C3%B4nica#Transistores Transistor como chave] para acionar uma carga elevada com uma única saída do Arduíno
| |
| :'''Exempĺo de uso''': Acionamento de vários leds com uma única saída do Arduíno no projeto de [http://200.17.101.9/wiki/index.php/Automa%C3%A7%C3%A3o_de_sem%C3%A1foro_com_Scratch_e_Ardu%C3%ADno Automação de Semáforo com Arduíno].
| |
| | |
| ==Informações sobre sensores e drives para uso com o Arduíno==
| |
| ;Sites de lojas virtuais: Arduíno, shields e acessórios
| |
| *[https://robocore.net/ Robocore]
| |
| | |
| ;Sensor Infravermelho
| |
| *http://bildr.org/2011/06/pir_arduino/
| |
| *https://www.sparkfun.com/datasheets/Sensors/Proximity/SE-10.pdf
| |
| | |
| ;Sensor Ultrasônico
| |
| *http://www.dfrobot.com/wiki/index.php?title=URM37_V3.2_Ultrasonic_Sensor_%28SKU:SEN0001%29
| |
| *[[Mídia:URM3.2_Mannual_Rev2.pdf | Manual URM3.2]]
| |
| | |
| ;Motores e drives
| |
| *[http://www.dfrobot.com/wiki/index.php?title=Arduino_Motor_Shield_%28L298N%29_%28SKU:DRI0009%29 Arduíno Motor Shield (L298N)]
| |
| *http://communityofrobots.com/tutorial/kawal/how-drive-dc-motor-using-l293d-arduino
| |
| | |
| =Exemplos de Aplicação com Arduíno=
| |
| | |
| ==Sensor de temperatura (LM35) ==
| |
| | |
| ;Componentes necessários
| |
| *Placa Arduino;
| |
| *Sensor de temperatura – LM35;
| |
| *Protoboard;
| |
| *Fios.
| |
| | |
| ;Funcionamento do sensor LM35: O LM35 tem uma resolução de 10mV por cada 1<sup>o</sup>C. Como sensor básico de temperatura, mede temperaturas entre 2<sup>o</sup>C e 150<sup>o</sup>C.
| |
| | |
| ;Esquema de ligação com Arduíno:
| |
| [[Arquivo:LM35.png|250px]]
| |
| _______
| |
| | |
| |
| | LM 35 |
| |
| |_______|
| |
| | | |
| |
| (+5v) ----+ | +---- (Ground)
| |
| |
| |
| Analog Pin
| |
| 0mV + 10mV / <sup>o</sup>C
| |
| | |
| ;Leitura pela entrada analógica do Arduíno: O Arduíno lê valores pelas '''entradas analógicas''' entre '''0V e 5V''' e os converte em números digitais com '''10 bits de magnitude''', ou seja, 2<sup>10</sup> valores (entre 0 e 1023).
| |
| | |
| O valor de tensão lido na entrada analógica do Arduíno (entre 0V e 5V) pode ser obtido multiplicando a leitura por 5/1023. Como a tensão medida pelo sensor varia 10mV/1<sup>o</sup>C, se multiplicarmos por 100, teremos o valor em graus Celcius:
| |
| ConversaoGrausCelcius = 5 / 1023 * 100 = 0,488758553
| |
| | |
| ;Montagem: Primeiramente, faça as ligações como mostra a imagem abaixo:
| |
| | |
| [[ Arquivo:LM351.png| 350px]]
| |
| | |
| :Agora, abra a IDE do Arduino e passe a seguinte programação
| |
| | |
| //Sensor de temperatura LM35
| |
| const float ConversaoGrausCelcius = 0.488758553;
| |
| //ConversaoGrausCelcius = 5 / 1023 * 100 = 0,488758553
| |
| float Temperatura;
| |
| void setup() {
| |
| Serial.begin(9600);
| |
| }
| |
| void loop() {
| |
| Temperatura = analogRead(A0) * ConversaoGrausCelcius;
| |
| Serial.print("Temperatura: ");
| |
| Serial.println(Temperatura);
| |
| delay(2000); //Tempo entre as leituras em ms
| |
| }
| |
| | |
| ;Instruções: Conecte o Arduino no PC, selecione a versão do seu Arduino e a porta e clique em UPLOAD. Agora abra o Serial Monitor e terá a temperatura atual, observe que a cada 2 segundo será feita uma nova leitura, caso queira aumentar ou diminuir este tempo deve ser alterado o tempo de leitura na linha dois do código.
| |
| | |
| ;Referencias:
| |
| #http://www.ajudino.com/2013/06/11-lendo-temperatura-com-lm35.html
| |
| #http://www.ti.com/lit/ds/symlink/lm35.pdf
| |
| | |
| ;Autoria: '''Igor Matheus B. Quintana''' / CST Análise e Desenvolvimento de Sistemas - IFPR - Câmpus Foz do Iguaçu
| |
| :--[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 14h33min de 29 de junho de 2015 (BRT)
| |
| | |
| ==Sensor de Temperatura NTC 10k==
| |
| | |
| O sensor de temperatura '''NTC 10k''' é um '''thermistor''', isto é, um resistor cuja resistência varia com a temperatura. | |
| | |
| Existem dois tipos de thermistores:
| |
| *NTC (Negative Temperature Coefficient), no qual a resistência diminui com o aumento da temperatura;
| |
| *PTC (Positive Temperature Coefficient), no qual a resistência aumenta com o aumento da temperatura.
| |
| | |
| Para leitura com o Arduíno, o sensor '''NTC 10k''' é utilizado numa estrutura com um [http://200.17.101.9/wiki/index.php/Resistores#Divisor_de_Tens.C3.A3o divisor de tensão] com um resistor de 10K Ω.
| |
| | |
| Esquema de ligação com Arduíno:
| |
| [[Arquivo:DivisorTensao-NTC10k.png]]
| |
| | |
| ;Equação de Steinhart–Hart: A equação de Steinhart–Hart (https://en.wikipedia.org/wiki/Thermistor), detalha a operação do thermistor NTC relacionando a variação de temperatura (Kelvin) com a resistência (Ω).
| |
| :<math>{1 \over T} = a + b\,\ln(R) + c\,(\ln(R))^3</math>
| |
| :onde a, b e c são parâmetros de Steinhart–Hart específicos para cada dispositivo.
| |
| :Valores típicos para um thermistor com resistência de 10K Ω na temperatura de (25 °C = 298.15 K) é:
| |
| :*a = 0.001129148,
| |
| :*b = 0.000234125,
| |
| :*c = 0.0000000876741.
| |
| | |
| ;Código para Arduíno: Referência: (http://playground.arduino.cc/ComponentLib/Thermistor2):
| |
| //Sensor de temperatura NTC10k
| |
| #include <math.h>
| |
| double Thermistor(int ADC) {
| |
| double R;
| |
| double logR;
| |
| double Temp;
| |
| R = 10000.0*((1024.0/ADC)-1); //Resistor do divisor de tensão 10k
| |
| logR = log(R);
| |
| Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * logR * logR ))* logR );
| |
| Temp = Temp - 273.15; // Conversão Kelvin para Celcius
| |
| return Temp;
| |
| }
| |
| void setup() {
| |
| Serial.begin(115200);
| |
| }
| |
| void loop() {
| |
| Serial.println(int(Thermistor(analogRead(0)))); // Mostra Graus Celcius
| |
| delay(1000);
| |
| }
| |
| | |
| ;Autoria: --[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 22h22min de 28 de junho de 2015 (BRT)
| |
| | |
| ==Sensor de Temperatura e Humidade DHT11==
| |
| | |
| O DHT11 é um sensor de temperatura e humidade. Este sensor inclui um medidor de humidade resistivo e um sensor de temperatura tipo NTC conectado a um microcontrolador de 8 bits (http://www.micro4you.com/files/sensor/DHT11.pdf).
| |
| | |
| O DHT11 possui uma biblioteca com funções prontas para seu funcionamento, documentada em [http://playground.arduino.cc/main/DHT11Lib playground.arduino.cc/DHT11]. Para uso, baixe a biblioteca [[Mídia:DHT11.zip |DHT11.zip]] e insira no ambiente da IDE do Arduíno:
| |
| Sketch -> Import Library -> Add Library
| |
| | |
| ;Esquema de ligação com Arduíno:
| |
| _______
| |
| | |
| |
| | DHT11 |
| |
| |_______|
| |
| | | |
| |
| (Ground) ----+ | +---- (+5v)
| |
| |
| |
| Analog Pin 1
| |
| | |
| ;Programa exemplo:
| |
| | |
| //Sensor de temperatura LDHT11
| |
| #include <dht11.h>
| |
| dht11 sensor; //Inicializa sensor
| |
| void setup() {
| |
| Serial.begin(9600);
| |
| delay(1000);
| |
| }
| |
| void loop() {
| |
| sensor.read(A1);
| |
| Serial.print("Temperatura (oC): ");
| |
| Serial.println(sensor.temperature);
| |
| Serial.print("Unidade (%): ");
| |
| Serial.println(sensor.humidity);
| |
| delay(2000); //Tempo entre as leituras em ms
| |
| }
| |
| | |
| ;Autoria: --[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 14h31min de 3 de julho de 2015 (BRT)
| |
| | |
| ==Sensor de força resistivo==
| |
| ;Funcionamento: O sensor de força resistivo funciona como um potenciômetro, isto é, se aplicar força na superfície, a resistência do sensor diminui. Se não tiver nada em cima do sensor, a resistência vai para mais de 20M ohm, tornando-se praticamente um circuito aberto. Este sensor consegue ler objetos com peso de 100g a 10Kg. É necessário que a força seja aplicada dentro da área de contato do sensor, se parte do objeto estiver fora desta área, o sensor não detectará ou dará uma leitura incorreta.
| |
| | |
| ;Componentes necessários:
| |
| *Placa Arduino;
| |
| *Conector Arduino;
| |
| *Protoboard;
| |
| *6 fios com conectores macho;
| |
| *1 resistor de 100K ohm (Marrom, preto, amarelo);
| |
| *Sensor de força resistivo.
| |
| | |
| ;Montegem: Primeiramente, faça as ligações como mostra a imagem abaixo
| |
| | |
| [[ Arquivo:Sensorforce.jpeg | 300px]]
| |
| | |
| :Agora, abra a IDE do Arduino e passe a seguinte programação
| |
| int Senval=0;
| |
| int Senpin=A0;
| |
| void setup()
| |
| {
| |
| Serial.begin(9600);
| |
| }
| |
| void loop()
| |
| {
| |
| Senval=analogRead(Senpin);
| |
| Serial.println(Senval);
| |
| delay(200);
| |
| }
| |
| | |
| ;Instruções: Conecte o Arduino no PC, selecione a versão do seu Arduino e a porta, clique em UPLOAD. Agora abra o Serial Monitor, ao aplicar uma força no sensor, verá que o número irá variar de 0 a 1023, a resistência vai alterar de acordo com a força aplicada sobre o sensor, consequentemente os valores mostrados no serial monitor mudarão.
| |
| | |
| ;Referência: https://www.sparkfun.com/products/9376
| |
| | |
| ;Autoria: '''Igor Matheus B. Quintana''' / CST Análise e Desenvolvimento de Sistemas - IFPR - Câmpus Foz do Iguaçu.
| |
| | |
| ==Controlando Leds pelo Monitor Serial==
| |
| | |
| ;Componentes necessários
| |
| *Placa Arduino;
| |
| *Conector Arduino
| |
| *Protoboard;
| |
| *5 fios com conectores macho;
| |
| *2 resistores de 220 ohm(Vermelho, vermelho, marrom);
| |
| *2 Leds.
| |
| | |
| ;Montagem: Primeiramente, faça as ligações como mostra a imagem abaixo:
| |
| | |
| [[Arquivo:SerialMonitorligadesliga1.png | 250px]]
| |
| | |
| :Agora, abra a IDE do Arduino e passe a seguinte programação
| |
| | |
| char c;
| |
| void setup(){
| |
| pinMode(2,OUTPUT);
| |
| pinMode(3,OUTPUT);
| |
| Serial.begin(9600);
| |
| }
| |
| void loop()
| |
| {
| |
| if (Serial.available() > 0)
| |
| {
| |
| c = Serial.read() - '0';
| |
| Serial.flush();
| |
| digitalWrite(c,!digitalRead(c));
| |
| }
| |
| }
| |
| | |
| ;Instruções: Conecte o Arduino no PC, selecione a versão do seu Arduino e a porta e clique em UPLOAD. Abra o Serial Monitor, ao digitar o número 2 no Serial Monitor, irá acender o LED conectado na porta digital 2 do Arduino, e ao digitar novamente o número 2, o LED apagará. Agora se digitar o número 3, irá acender o LED da porta digital 3 e se digitar novamente o número 3, o LED apagará.
| |
| | |
| ;Autoria: '''Igor Matheus B. Quintana''' / CST Análise e Desenvolvimento de Sistemas - IFPR - Câmpus Foz do Iguaçu.
| |
| | |
| ==Comunicação Serial==
| |
| ;Informações sobre comunicação serial e paralela:
| |
| *[[Comunicação serial e paralela]]
| |
| *[http://www.embarcados.com.br/arduino-comunicacao-serial Comunicação serial com Arduíno]/
| |
| | |
| ;Comunicação Serial entre dois Arduínos:
| |
| | |
| ;:Emissor
| |
| :Insere na porta serial os valores 0 e 1 de maneira alternada a cada dois segundos.
| |
| | |
| ;:Receptor
| |
| :Faz a leitura dos valores escritos pelo emissor e controla o LED.
| |
| :0 -> LED apagado.
| |
| :1 -> LED aceso.
| |
| | |
| :[[Arquivo:SerialArduino.jpg | 400px]]
| |
| | |
| Código do Arduíno emissor
| |
| //emissor
| |
| int num = 0;
| |
| void setup(){
| |
| Serial.begin(9600);
| |
| }
| |
| void loop(){
| |
| num = 0;
| |
| Serial.write(num);
| |
| delay(2000);
| |
| num = 1;
| |
| Serial.write(num);
| |
| delay(2000);
| |
| }
| |
| | |
| Código do Arduíno receptor
| |
| //receptor
| |
| int recByte;
| |
| int led = 13;
| |
| void setup(){
| |
| Serial.begin(9600);
| |
| pinMode(led,OUTPUT);
| |
| }
| |
| void loop(){
| |
| if (Serial.available ()> 0)
| |
| {
| |
| recByte = Serial.parseInt();
| |
| //parseInt() retorna o primeiro número inteiro válido do buffer serial.
| |
| //Caracteres e não inteiros são ignorados.
| |
| }
| |
| if(recByte == 0){
| |
| digitalWrite(led,LOW);
| |
| }else if(recByte == 1){
| |
| digitalWrite(led,HIGH);
| |
| }
| |
| }
| |
| | |
| ===Arduíno Leonardo===
| |
| O '''Arduíno Leonardo''' usa a '''Serial''' exclusivamente para comunicação com a '''porta USB'''. Para comunicação serial TTL (5V) nos pinos 0 (RX) and 1 (TX) deve-se utilizar a '''Serial1'''.
| |
| | |
| ;Autoria: '''Matheus Marques''' / CST Análise e Desenvolvimento de Sistemas - IFPR - Câmpus Foz do Iguaçu
| |
| | |
| ==Comunicação com módulo Bluetooth==
| |
| | |
| O '''módulo Bluetooth''' permite interagir com o Arduíno, por exemplo, utilizando um aplicativo em um smartphone.
| |
| | |
| Um módulo Bluetooth bastante utilizado é o HC06 (ver: http://www.instructables.com/id/Add-bluetooth-to-your-Arduino-project-ArduinoHC-06):
| |
| | |
| [[Arquivo:Bleutooth-HC06.png|300px]]
| |
| | |
| ===Pinagem e conexão com o Arduíno===
| |
| | |
| Este módulo apresenta 6 pinos, mas com apenas 4 pinos é possível colocar o mesmo para funcionar e fazer o Arduíno interagir dispositivos Bluetooth.
| |
| _________
| |
| | |
| |
| | |
| |
| | |
| |
| |Bleutooth|
| |
| | |
| |
| | HC06 |
| |
| | |
| |
| | |
| |
| |_________|
| |
| | | | |
| |
| Vcc ----+ | | +---- Txd
| |
| Gnd ------+ +------ Rxd
| |
| Cuidados com a conexão do módulo Bluetooth HC06 com o Arduíno:
| |
| *O HC06 funciona com alimentação '''Vcc=3,3V''', a qual também é fornecida pelo Arduino ao lado da alimentação de 5V;
| |
| *Na comunicação serial, como o Arduíno fornece 5V, é necessário utilizar um '''[http://200.17.101.9/wiki/index.php/Resistores#Divisor_de_Tens.C3.A3o divisor de tensão]''' na entrada Rxd do HC06, conforme exemplo abaixo:
| |
| [[Arquivo:DivisorTensao-Bleutooth.png]]
| |
| V<sub>Rxd</sub> = R2/(R1 + R2).5
| |
| :Exemplo:
| |
| R1=470 Ω, R2=1 KΩ -> V<sub>Rxd</sub> = 3,4 V
| |
| | |
| ===Exemplos de programas de aplicação===
| |
| Fonte: http://www.instructables.com/id/Add-bluetooth-to-your-Arduino-project-ArduinoHC-06
| |
| ;Echo Code: Permite enviar uma string ao '''Arduíno''' via Bluetooth e receber de volta a mesma string no '''monitor serial'''.
| |
| | |
| String message; //string that stores the incoming message
| |
| void setup()
| |
| {
| |
| Serial.begin(9600); //set baud rate
| |
| }
| |
| void loop()
| |
| {
| |
| while(Serial.available())
| |
| {//while there is data available on the serial monitor
| |
| message+=char(Serial.read());//store string from serial command
| |
| }
| |
| if(!Serial.available())
| |
| {
| |
| if(message!="")
| |
| {//if data is available
| |
| Serial.println(message); //show the data
| |
| message=""; //clear the data
| |
| }
| |
| }
| |
| delay(1000); //delay
| |
| }
| |
| | |
| ;Led Code: Permite acender e apagar um '''led''' conectado ao '''Arduíno''' enviando caracteres via '''Bluetooth''' de um '''''smartphone''''' ou outro dispositivo Bluetooth.
| |
| | |
| char blueToothVal; //value sent over via bluetooth
| |
| char lastValue; //stores last state of device (on/off)
| |
| void setup()
| |
| {
| |
| Serial.begin(9600);
| |
| pinMode(13,OUTPUT);
| |
| }
| |
| void loop()
| |
| {
| |
| if(Serial.available())
| |
| {//if there is data being recieved
| |
| blueToothVal=Serial.read(); //read it
| |
| }
| |
| if (blueToothVal=='n')
| |
| {//if value from bluetooth serial is n
| |
| digitalWrite(13,HIGH); //switch on LED
| |
| if (lastValue!='n')
| |
| Serial.println(F("LED is on")); //print LED is on
| |
| lastValue=blueToothVal;
| |
| }
| |
| else if (blueToothVal=='f')
| |
| {//if value from bluetooth serial is n
| |
| digitalWrite(13,LOW); //turn off LED
| |
| if (lastValue!='f')
| |
| Serial.println(F("LED is off")); //print LED is on
| |
| lastValue=blueToothVal;
| |
| }
| |
| delay(1000);
| |
| }
| |
| | |
| ====''Smartphone'' Android====
| |
| Para enviar caracteres de um '''''Smartphone'' Android''' para o módulo '''Bluetooth''' pode-se utilizar aplicativos como o [https://play.google.com/store/apps/details?id=com.ucconnect.ucbtadapter_hex&hl=pt-BR Bluetooth Serial Port Terminal].
| |
| | |
| ====Arduíno Leonardo====
| |
| O '''Arduíno Leonardo''' usa a '''Serial''' exclusivamente para comunicação com a '''porta USB'''. Para comunicação serial TTL (5V) nos pinos 0 (RX) and 1 (TX) deve-se utilizar a '''Serial1'''.
| |
| | |
| ;Tradução e adaptação: --[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 12h49min de 3 de agosto de 2015 (BRT)
| |
| | |
| ==Comunicação sem fio com Wireless Shield e Xbee==
| |
| | |
| O '''[https://www.arduino.cc/en/Main/ArduinoWirelessShield Wireless Shield]''' permite a '''comunicação serial sem fio''' baseado no módulo '''[http://www.digi.com/products/wireless-wired-embedded-solutions/zigbee-rf-modules/zigbee-mesh-module/xbee-zigbee Xbee]''' da Digi.
| |
| | |
| [[Arquivo:Arduino_WirelessSDShield.jpg|300px]]
| |
| | |
| ===Configuração do Wireless Shield===
| |
| A placa '''Wireless Shield''' possui uma '''chave de configuração''' da comunicação serial entre o módulo '''Xbee''' e o '''microcontrolador do Arduino''' e o '''conversor serial USB''' (ver: https://www.arduino.cc/en/Main/ArduinoWirelessShield):
| |
| | |
| [[Arquivo:WirelessShield_SD_switchUSB.png|100px]]
| |
| | |
| *'''Posição micro''': O pino Dout do módulo Wireless é conectado ao pino RX do microcontrolador do Arduino e o pino Din ao pino TX do microcontrolador. '''O módulo sem fio se comunica de forma serial com o microcontrolador do Arduino.''' Destaca-se que os pinos TX e RX do microcontrolador também continuam conectados aos pinos RX e TX do conversor serial USB. Desta forma, dados transmitidos pelo microcontrolador serão enviados simultaneamente ao módulo sem fio e a serial USB. Neste modo o microcontrolador do Arduino não pode ser programado via USB.
| |
| *'''Posição USB''': O pino Dout do módulo Wireless é conectado ao pino RX do conversor serial USB e o pino Din ao pino TX do conversor serial USB. '''O módulo sem fio se comunica diretamente com o computador.''' Para usar este modo o microcontrolador do Arduíno deve ser programado com um '''sketch vazio''':
| |
| void setup() { }
| |
| void loop() { }
| |
| | |
| ;Xbee Explorer USB: A placa '''Wireless Shield''' com a chave na '''posição USB''' e o '''microcontrolador do Arduíno''' programado com '''sketch vazio''' se comporta como um módulo '''Xbee Explorer USB''', com o Xbee se comunicando diretamente com o computador.
| |
| | |
| [[Arquivo:XbeeExplorerUSB.png|200px]]
| |
| | |
| ===Exemplo de utilização===
| |
| Exemplo de comunicação usando a '''configuração padrão''' dos módulos '''Xbee''', apresentado em https://www.arduino.cc/en/Guide/ArduinoWirelessShield:
| |
| | |
| *Para fazer a carga de programas no microcontrolador do Arduíno, colocar a '''chave''' do módulo wireless na '''posição USB'''.
| |
| *Em um dos Arduínos com módulo Wireless carregar o programa
| |
| Exemples->Communication->Physical Pixel
| |
| :Este programa faz o Arduíno acender ou apagar o led da porta 13 a partir do envio do caracter H ou L a partir do '''monitor serial'''. Testar o funcionamento do programa com a chave do módulo wireless na '''posição USB'''. Em seguida desconectar o Arduíno da interface USB e mudar a chave do módulo wireless para a '''posição micro'''.
| |
| *Em outro Arduíno com módulo wireless, carregar o programa abaixo com chave do módulo wireless na '''posição USB'''. Verificar o funcionamento do programa no '''monitor serial'''. Depois de carregado o programa mudar a chave do módulo wireless para a '''posição micro'''.
| |
| void setup()
| |
| {
| |
| Serial.begin(9600);
| |
| }
| |
| void loop()
| |
| {
| |
| Serial.print('H');
| |
| delay(1000);
| |
| Serial.print('L');
| |
| delay(1000);
| |
| }
| |
| *Para '''testar a comunicação serial sem fio''', conectar o primeiro Arduíno na fonte de alimentação e verificar se a comunicação entre os Arduínos acontece, fazendo o led piscar.
| |
| **Caso não haja comunicação, tente restabelecer a '''configuração padrão''' ('''''default''''') nos módulos '''Xbee''' (veja abaixo).
| |
| | |
| ====Arduíno Leonardo====
| |
| O '''Arduíno Leonardo''' usa a '''Serial''' exclusivamente para comunicação com a '''porta USB'''. Para comunicação serial TTL (5V) nos pinos 0 (RX) and 1 (TX) deve-se utilizar a '''Serial1'''.
| |
|
| |
|
| ===Endereçamento dos módulos Xbee===
| | Uma vez instalado o ArduBlock é incorporado na própria IDE do Arduíno. Assim, um programa construído com o ArduBlock é exportado para a IDE na forma de código na linguagem C do Arduíno. |
| Vários parâmetros precisam ser configurados para que os módulos Xbee possam se comunicar:
| |
| #Os dispositivos precisam estar na mesma '''rede''', definida pelo parâmetro '''ID''';
| |
| #Os dispositivos precisam usar o mesmo '''canal''', definido pelo parâmetro '''CH''';
| |
| #O '''endereço destino''' (DH e DL) determina qual módulo da rede receberá os dados:
| |
| #*Se o '''DH = 0''' e o '''DL < 0xFFFF''' (i.e. 16 bits), o dado transmitido pelo módulo será recebido por qualquer módulo cujo '''endereço''' de 16-bit '''MY''' é igual a '''DL''';
| |
| #*Se o '''DH = 0''' e o '''DL = 0xFFFF''', o dado transmitido será recebido por '''todos''' os módulos (''broadcast'');
| |
| #*Se o '''DH ≠ 0''' e o '''DL > 0xFFFF''', o dado transmitido será recebido somente pelo módulo cujo '''número serial''' seja igual ao '''endereço destino''' (i.e. '''SH = DH''' e '''SL = DL''').
| |
|
| |
|
| Síntese de alguns parâmetros:
| | ;Instalação: |
| {| border=1
| | #Baixar o arquivo '''ardublock-all.jar''' do site [https://sourceforge.net/projects/ardublock/ '''ArduBlock'''] (remover do nome do arquivo a data de compilação, deixando ardublock-all.jar); |
| |-
| | #Verificar no diretório home a pasta '''sketchbook''' (ou '''Arduino''', dependendo da versão da IDE) e criar nela os subdiretórios indicados para colocar o arquivo ardublock-all.jar ('''tools/ArduBlockTool/tool/ardublock-all.jar'''); |
| | '''Parâmetro''' || '''Descrição''' || '''Valor default'''
| | #Reiniciar a IDE do Arduíno; |
| |-
| | #O '''ArduBlock''' é acessado através da guia '''Tools'''. |
| | ID || Identificador de rede || 3332
| |
| |-
| |
| | CH || Canal || C
| |
| |-
| |
| | SH SL || Numero de série || Diferente para cada módulo
| |
| |-
| |
| | MY || Endereço do módulo || 0
| |
| |-
| |
| | DH DL || Endereço destino || 0
| |
| |-
| |
| | BD || Vazão da comunicação serial (bps) || 3 (9600 bps)
| |
| |}
| |
|
| |
|
| ===Configuração do módulo Xbee===
| | [[Arquivo:ArduBlock.png|500px]] --> |
|
| |
|
| Para a configuração do módulo Xbee é interessante utilizar o software [http://www.digi.com/support/productdetail?pid=3352 XCTU] da Digi ou o [http://www.moltosenso.com/ moltosenso Network Manager], os quais apresentam facilidades para configuração e atualização dos módulos wireless.
| | ==SimulIDE: Ambiente de simulação para Arduíno== |
|
| |
|
| ;Exemplo de configuração com o software moltosenso Network Manager: Baixar e instalar o software '''moltosenso Network Manager IRON 1.0''' (''Free''):
| | Existem diversos '''ambientes de simulação''' para o Arduíno, como o '''[https://www.simulide.com SimulIDE]''' e o '''[https://www.tinkercad.com TinkerCAD''']. |
|
| |
|
| *Na guia '''''Port Setup''''' é possível verificar a configuração da porta, clique em '''''Open Port''''' e verifique se o dispositivo foi detectado;
| | O '''SimulIDE''' é um simulador para '''Arduíno''' e '''circuitos eletrônicos''' que pode ser instalado em diferentes sistemas operacionais, sendo um sistema leve e fácil de utilizar. |
| *Clique no dispositivo e verifique as informações do mesmo em '''''Current Device''''';
| |
| [[Arquivo:moltosenso.png|400px]]
| |
| *Na guia '''''Node Settings''''' é possível selecionar o módulo e verificar seus parâmetos de configuração;
| |
| [[Arquivo:moltosenso2.png|400px]]
| |
| *Para '''restaurar os parâmetros ''default''''' do dispositivo clique em '''''Restore All''''' e depois em '''''Write Permanently''''';
| |
|
| |
|
| ;Adaptação e autoria: --[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 20h19min de 12 de julho de 2015 (BRT) | | ;Instalação do SimulIDE no Ubuntu 20.04: Baixar a versão compatível com o sistema operacional de extrair o conteúdo do arquivo .tar.gz. |
| | :Instalar dependências que precisam para o programa e estão descritas no arquivo README.md. |
| | :Podem ser instaladas com o comando: |
| | sudo apt-get install libqt5core5a libqt5gui5 libqt5xml5 libqt5svg5 libqt5widgets5 libqt5concurrent5 libqt5multimedia5 libqt5multimedia5-plugins libqt5serialport5 libqt5script5 libelf1 |
| | :O diretório "SimulIDE_x.x.x" tem tudo o que precisa para rodar o programa, ir até ele e executar: |
| | ./simulide |
|
| |
|
| ==Comunicação com o Ethernet Shield== | | ===Programação do Arduíno no SimulIDE=== |
|
| |
|
| Este exemplo mostra como utilizar o '''Ethernet Shield''' juntamente com o '''Arduíno''' para criar um '''Web Server''' que forneça informações sobre sensores conectados a entradas analógicas (Ver: https://www.arduino.cc/en/Tutorial/WebServer).
| | A programação do Arduíno no '''SimulIDE''' pode ser realizada utilizando a própria '''IDE do Arduíno''', o que é interessante pelo fato de dispor de todos os exemplos prontos de programas. |
|
| |
|
| Usando a biblioteca '''Ethernet.h''', o Arduíno pode responder a requisições HTTP através do '''Ethernet Sheild'''.
| | ;IDE Arduíno: Procedimentos: |
| | *'''Compilar''' o programa; |
| | *'''Exportar binário compilado''' (.hex) |
| | /sketch/Exportar Binário compilado |
| | ;SimulIDE: Procedimentos: |
| | *Clicar com o botão direito do mouse sobre o Arduíno e selecionar '''Load firmware'''; |
| | *Selecionar arquivo '''binário compilado''' (.hex). |
|
| |
|
| O '''Ethernet Shield''' permite conectar o controlador '''Ethernet WizNet''' ao Arduíno usando o '''barramento SPI'''. O barramento SPI (Serial Peripheral Interface) é um interface de comunicação serial síncrona usada para comunicação em distâncias curtas, e usa a biblioteca '''SPI.h'''. | | ====Uso do compilador no próprio SimulIDE==== |
| | O '''SimulIDE''' também apresenta uma área para '''edição de programa''', a qual pode ser utilizada para '''edição''', '''compilação''' e '''carga do programa''' no módulo de simulação. |
|
| |
|
| O barramento SPI usa os pinos 10, 11, 12 e 13 do Arduíno para implementar a conexão SPI com o WizNet. O Ethernet Shield possui ainda um slot para cartão SD e usa o pino 4 para controlar o pino de seleção do cartão SD.
| | Para utilizar esta facilidade do SimulIDE deve-se clicar com o botão direito do mouse na área de '''edição de programas''' e configurar o parâmetro '''Compiler path'''. O compilador o simulador utiliza o próprio compilador da IDE do Arduíno, portanto, deve-se configurar o caminho onde o programa está localizado. |
|
| |
|
| ===Exemplo==-
| | Para descobrir o caminho onde está rodando a '''IDE do Arduíno''', pode habilitar as mensagens do compilador na IDE em |
| | Arquivo/Preferências/Mostrar mensagens de saída durante compilação |
| | Depois compilar um arquivo e verificar caminho onde o programa está instalado. |
|
| |
|
| /*
| | ===Binários compilados=== |
| Web Server para fornecer a temperatura usando sensor LM35
| | Quando exportamos o '''binário compilado''' são gerados dois arquivos '''.hex''': |
| O sensor de temperatura (LM35) é conectado a entrada analógica 0 do Arduino.
| | ino.standard.hex |
| | |
| | ino.with_bootloader.standard.hex |
|
| |
|
| Based in Sketche: Arduino -> Ethernet -> BarometricPressureWebServer
| | Como o nome indica, o primeiro não inclui o '''''bootloader'''''. Quando fazemos um '''carga normal''' de programa no Arduíno via '''USB''', o '''''bootloader''''' instalado no módulo recebe os dados pela '''comunicação serial''' e escreve o programa na '''memória ''flash'''''. |
| by Tom Igoe (2010)
| |
| */
| |
| #include <Ethernet.h>
| |
| #include <SPI.h>
| |
| // assign a MAC address for the ethernet controller.
| |
| byte mac[] = {
| |
| 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
| |
| // assign an IP address for the controller:
| |
| IPAddress ip(192,168,1,20);
| |
| IPAddress gateway(192,168,1,1);
| |
| IPAddress subnet(255, 255, 255, 0);
| |
| // Initialize the Ethernet server library
| |
| // (port 80 is default for HTTP):
| |
| EthernetServer server(80);
| |
| //Sensor de temperatura LM35
| |
| //ConversaoGrausCelcius = 5 / 1023 * 100 = 0,488758553
| |
| const float ConversaoGrausCelcius = 0.488758553;
| |
| float SensorLM35;
| |
| void setup() {
| |
| // Open serial communications and wait for port to open:
| |
| Serial.begin(9600);
| |
| while (!Serial) {
| |
| ; // wait for serial port to connect. Needed for Leonardo only
| |
| }
| |
| // start the Ethernet connection and the server:
| |
| Ethernet.begin(mac, ip);
| |
| server.begin();
| |
| // give the sensor and Ethernet shield time to set up:
| |
| delay(1000);
| |
| Serial.print("server is at ");
| |
| Serial.println(Ethernet.localIP());
| |
| }
| |
| void loop() {
| |
| // Faz a leitura do sensor periodicamente.
| |
| Serial.print('.');
| |
| //Le Sensor LM35 na entrada analogica 0
| |
| SensorLM35 = analogRead(A0) * ConversaoGrausCelcius;
| |
| // listen for incoming Ethernet connections:
| |
| listenForEthernetClients();
| |
| delay(1000);
| |
| }
| |
| void listenForEthernetClients() {
| |
| // listen for incoming clients
| |
| EthernetClient client = server.available();
| |
| if (client) {
| |
| Serial.println("Got a client");
| |
| // an http request ends with a blank line
| |
| boolean currentLineIsBlank = true;
| |
| while (client.connected()) {
| |
| if (client.available()) {
| |
| char c = client.read();
| |
| Serial.write(c);
| |
| // if you've gotten to the end of the line (received a newline
| |
| // character) and the line is blank, the http request has ended,
| |
| // so you can send a reply
| |
| if (c == '\n' && currentLineIsBlank) {
| |
| // send a standard http response header
| |
| client.println("HTTP/1.1 200 OK");
| |
| client.println("Content-Type: text/html");
| |
| client.println("Connection: close"); // the connection will be closed after completion of the response
| |
| // client.println("Refresh: 5"); // refresh the page automatically every 5 sec
| |
| client.println();
| |
| client.println("<!DOCTYPE HTML>");
| |
| client.println("<html>");
| |
| // output the value of temperature
| |
| client.print("Temperatura interna (oC) = ");
| |
| client.print(SensorLM35);
| |
| client.println("<br />");
| |
| client.print(SensorDH11);
| |
| client.println("<br />");
| |
| client.println("<br />");
| |
| client.println("</html>");
| |
| break;
| |
| }
| |
| if (c == '\n') {
| |
| // you're starting a new line
| |
| currentLineIsBlank = true;
| |
| }
| |
| else if (c != '\r') {
| |
| // you've gotten a character on the current line
| |
| currentLineIsBlank = false;
| |
| }
| |
| }
| |
| }
| |
| // give the web browser time to receive the data
| |
| delay(1);
| |
| // close the connection:
| |
| client.stop();
| |
| Serial.println("client disonnected");
| |
| }
| |
| }
| |
|
| |
|
| | O binário <code>ino.with_bootloader.standard.hex</code> é utilizado quando se usa um '''programador externo''', conectado aos pinos ICSP da placa, para gravar o programa na '''memória ''flash''''' do '''microcontrolador'''. Neste caso, o programador externo sobre-escreve o ''bootloader'' instalado no módulo, portanto, é necessário incluir a parte do ''bootloader'' para o módulo funcionar. |
|
| |
|
| ;Adaptação e autoria: --[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 19h00min de 12 de agosto de 2015 (BRT)
| | ==Referências== |
| | <references /> |
|
| |
|
| ---- | | ---- |
|
| |
|
| [[Categoria:Arduíno]] | | [[Categoria:Arduíno]] [[Categoria:IoT]] |
