Arduino: mudanças entre as edições

De Wiki Cursos IFPR Foz
Ir para navegaçãoIr para pesquisar
 
(92 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].
 
==Introdução a Computação com Arduíno==
 
;[[Introdução a Computação com Arduíno]]: Usa o Arduíno para desenvolver conceitos sobre computação e informática.
 
==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 &Omega;.
 
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 (&Omega;).
:<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 Pressão Barométrica BMP180==
 
Referência: [https://learn.sparkfun.com/tutorials/bmp180-barometric-pressure-sensor-hookup- Tutorial Sparkfun BMP180]
 
O '''BMP180''' é um '''sensor de pressão barométrica''', o qual mede a '''pressão absoluta''' do ar ao seu redor. A pressão do ar varia com as '''condições do tempo''' e também com a '''altitude'''. Portanto, dependendo de como os dados medidos forem interpretados, pode-se tanto aferir mudanças nas condições do tempo como na altitude.
 
;Interface I<sup>2</sup>C: O '''BMP180''' utiliza uma interface '''I<sup>2</sup>C''' para se comunicar com o microcontrolador do Arduíno. A interface I<sup>2</sup>C é padronizada para conectar dispositivos periféricos de baixa velocidade a uma placa mãe ou sistema embarcado e usa duas linhas para comunicação: Dados Seriais (''Serial Data'' - SDA) e Clock Serial (''Serial Clock'' - SCL). O clock é gerado pelo mestre e a linha de dados seriais é bidirecional.
 
;Conexões com o hardware do sensor: O sensor BMP180 possui 4 pinos para conexão com o Arduíno:
* '''+''' (VDD): '''3,3 V''' (Não alimentar com 5 V sob risco de danificar o compomente);
* '''-''' (GND): '''Terra''';
* '''DA''' (SDA) (I<sup>2</sup>C data): Conectar ao pino '''A4''' UNO
* '''CL''' (SCL) (I<sup>2</sup>C clock): Conectar ao pino '''A5''' UNO
* '''IO''': Não usado com Arduíno (serve para microcontroladores que operam em baixa voltagem)
:Para Arduíno Leonardo ou Mega, verificar o pino de conexão no tutorial [https://learn.sparkfun.com/tutorials/bmp180-barometric-pressure-sensor-hookup- Sparkfun BMP180].
 
[[Arquivo:BMP180.png]]
 
;Instalação da biblioteca para o BMP180: O sensor BMP180 possui uma biblioteca e exemplos que facilitam a comunicação com o sensor e o desenvolvimento de programas. Para uso com o Arduíno, baixar a biblioteca [https://github.com/sparkfun/BMP180_Breakout_Arduino_Library/archive/master.zip SFE_BMP180] e instalar na IDE do Arduíno com os comandos:
Scketch -> Import Library -> Add library
 
;Exemplos: Há dois exemplos incluídos junto com a instalação da biblioteca, que podem ser utilizados para testar o sensor BMP180 e também serem utilizados como referência para a construções de novos programas:
#'''Medição de temperatura e pressão absoluta e relativa''': Este exemplo mostra a medição de '''temperatura''' e '''pressão barométrica absoluta e relativa''', calculada a partir da '''altitude''' fornecida para o lugar da medição.
#'''Medição de altitude''': Mostra como medir a '''altitude''' de um lugar, a partir da calibração do sensor para uma altitude conhecida e utilizando o barômetro para medir as variações de altitude.
 
===Medição de tempo e altitude===
 
O '''BMP180''' é um '''sensor de pressão barométrica''' e pode ser usado tanto aferir mudanças nas '''condições do tempo''' como na '''altitude''' [https://learn.sparkfun.com/tutorials/bmp180-barometric-pressure-sensor-hookup-].
 
====Pressão atmosférica====
A '''pressão''' é medida pela '''força''' por unidade de '''área'''. No Sistema Internacional é medida por '''newton''' por '''metro quadrado''', ou  '''pascal''' ('''Pa''').
 
A '''pressão atmosférica''' é dada pela força exercida pelo ar que forma a atmosfera sobre a superfície da terra. Uma coluna de ar de um centímetro quadrado, ao nível do mar, pesa aproximadamente um quilograma, ou 101325 pascals. Em uma altitude de 3810 m, a pressão atmosférica é a metade da pressão ao nível do mar.
 
O '''BMP180''' mede a '''pressão absoluta''' em '''pascal''' ('''Pa'''). Entretanto, um pascal é uma unidade muito pequena, sendo normalmente a pressão dada em hectopascals (1 hPa = 100 Pa). Outras unidades utilizadas para medir a pressão atmosférica são o '''bar''' e o '''atm''':
* 1 mbar = 1 hPa
* 1 atm = 101 325 Pa = 1013,25 hPa = 1013,25 mbar = 1,01325 bar (Pressão atmosférica ao nível do mar)
 
====Efeito da temperatura====
 
A '''temperatura''' afeta a '''densidade''' de um gaz, a densidade de um gaz afeta a '''massa''' do gaz, e a massa do gaz afeta a '''pressão''', portanto, a '''pressão atmosférica''' é bastante influenciada pela variação da '''temperatura'''.


====Observações do tempo====
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.


A '''pressão atmosférica''' em um dado ponto da terra não é constante. Há uma interação complexa entre o movimento de rotação da terra, a inclinação do eixo da terra, e muitos outros fatores relacionados ao movimento das áreas de alta e baixa pressão. Todavia, observando a '''variação de pressão''' em um dado ponto é possível fazer '''previsões de curto prazo sobre o tempo'''. Por exemplo, '''quedas de pressão''' normalmente indicam '''mau tempo''' (chuva) ou tormenta se aproximando. '''Subida de pressão''' normalmente indica que o '''tempo bom''' (seco) está chegando.  
;Instalação:
#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''');
#Reiniciar a IDE do Arduíno;
#O '''ArduBlock''' é acessado através da guia '''Tools'''.


====Efeito da altitude====
[[Arquivo:ArduBlock.png|500px]] -->


A '''pressão atmosférica''' também varia com a '''altitude'''. A pressão medida em um dado local é a '''pressão absoluta'''. Para comparar a pressão em dois lugares com altitude diferente, deve-se descontar os efeitos da altitude, gerando o que se chama '''pressão relativa'''.
==SimulIDE: Ambiente de simulação para Arduíno==


Na biblioteca do BP180 a função '''seaLevel(P,A)''' utiliza como parâmetros a '''pressão absoluta (P)''' em hPa, e a '''altitude corrente (A)''' em metros, para devolver a '''pressão relativa'''. A partir da pressão relativa é possível comparar as pressões atmosféricas em diferentes pontos da terra.
Existem diversos '''ambientes de simulação''' para o Arduíno, como o '''[https://www.simulide.com SimulIDE]''' e o '''[https://www.tinkercad.com TinkerCAD'''].


====Determinando a altitude====
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.


Uma vez que a '''pressão atmosférica varia com a altitude''', é possível utilizar o medidor de pressão atmosférica para aferir a altitude de um local.
;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


A pressão atmosférica média ao nível do mar é 1013.25 hPa e cai a zero no vácuo do espaço.
===Programação do Arduíno no SimulIDE===


A variação da altitude entre duas medidas de pressão (p e p<sub>0</sub>) é dada pela fórmula:
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.


<math>altitude = 44330 * ( 1 - ({p \over p_0})^{1 \over 5.255})</math>
;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).


Formas de utilizar esta equação:
====Uso do compilador no próprio SimulIDE====
#Se utilizarmos p<sub>0</sub> como a pressão atmosférica ao nível do mar (1013.25 hPa), teremos a altitude acima do nível do mar do local;
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.
#Se utilizarmos p<sub>0</sub> como a pressão atmosférica do um local com altitude conhecida, teremos a altitude relativa, podendo ser positiva ou negativa, dependendo se subirmos ou descermos em relação a altitude conhecida.


N altitude(P,P0)
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.


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===
 
Quando exportamos o '''binário compilado''' são gerados dois arquivos '''.hex''':
;Adaptação e autoria: --[[Usuário:Evandro.cantu|Evandro.cantu]] ([[Usuário Discussão:Evandro.cantu|discussão]]) 10h33min de 23 de agosto de 2015 (BRT)
  ino.standard.hex
 
==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 &Omega;, R2=1 K&Omega; -> 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'''.
 
//  Physical Pixel
const int ledPin = 13; // the pin that the LED is attached to
int incomingByte;      // a variable to read incoming serial data into
void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}
void loop() {
  if (Serial.available() > 0) {
    incomingByte = Serial.read();
    if (incomingByte == 'H') {
      digitalWrite(ledPin, HIGH);
    }
    if (incomingByte == 'L') {
      digitalWrite(ledPin, LOW);
    }
  }
}
   
   
*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'''.
  ino.with_bootloader.standard.hex
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===
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 &ne; 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:
{| border=1
|-
| '''Parâmetro''' || '''Descrição''' || '''Valor default'''
|-
| 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===
 
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.
 
;Exemplo de configuração com o software moltosenso Network Manager: Baixar e instalar o software '''moltosenso Network Manager IRON 1.0''' (''Free''):
 
*Na guia '''''Port Setup''''' é possível verificar a configuração da porta, clique em '''''Open Port''''' e verifique se o dispositivo foi detectado;
*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)
 
==Comunicação com o Ethernet Shield==
 
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).
 
Usando a biblioteca '''Ethernet.h''', o Arduíno pode responder a requisições HTTP através do '''Ethernet Sheild'''.
 
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'''. 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.
 
===Exemplo===


/*
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'''''.
  Web Server para fornecer a temperatura usando sensor LM35
  O sensor de temperatura (LM35) é conectado a entrada analógica 0 do Arduino.
  Based in Sketche: Arduino -> Ethernet -> BarometricPressureWebServer
  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
EthernetServer server(80);
//Sensor de temperatura LM35
//ConversaoGrausCelcius = 5 / 1023 * 100 = 0,488758553
const float ConversaoGrausCelcius = 0.488758553;
float  SensorLM35;
void setup() {
    Serial.begin(9600);
  // start the Ethernet connection and the server:
  Ethernet.begin(mac, ip);
  server.begin();
  delay(1000);
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}
void loop() {
  // Faz a leitura do sensor periodicamente.
  Serial.print('.');
  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 (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"); 
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");       
          // output the value of temperature         
          client.print("Temperatura interna (oC) = ");
          client.print(SensorLM35);
          client.println("</html>");
          break;
        }
        if (c == '\n') {
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          currentLineIsBlank = false;
        }
      }
    }
    delay(1);
    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]]

Edição atual tal como às 20h49min de 9 de maio de 2023

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 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

Algumas placas Arduino

Arduino UNO

Arduino Micro

Arduino Mega

Hardware do Arduíno UNO [1]

  • 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

Voltagens de alimentação

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.
  • Vin Quando utilizado fonte externa a tensão da mesma pode ser obtida aqui.
  • IOref 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).
Aref 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 Aref.
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 [2].

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

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 .ino.

A própria IDE do Arduíno apresenta vários exemplos de aplicações e programas que ajudam quem está iniciando a programá-lo.

SimulIDE: Ambiente de simulação para Arduíno

Existem diversos ambientes de simulação para o Arduíno, como o SimulIDE e o TinkerCAD.

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.

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

Programação do Arduíno no SimulIDE

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.

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).

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.

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.

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

Quando exportamos o binário compilado são gerados dois arquivos .hex: 

ino.standard.hex

ino.with_bootloader.standard.hex

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.

O binário ino.with_bootloader.standard.hex é 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.

Referências

  1. ↑ https://www.arduino.cc/en/Main/ArduinoBoardUno
  2. ↑ https://www.arduino.cc/en/Tutorial/SecretsOfArduinoPWM
Disponível em “http://wiki.foz.ifpr.edu.br/wiki/index.php?title=Arduino&oldid=30291”