Arduino Datalogger: 8 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Neste tutorial, faremos um registrador de dados simples usando o Arduino. O objetivo é aprender o básico do uso do Arduino para capturar informações e imprimir no terminal. Podemos usar esta configuração básica para completar uma série de tarefas.

Para começar:

Você precisará de uma conta do Tinkercad (www.tinkercad.com). Acesse e inscreva-se com seu e-mail ou conta de mídia social.

O login leva você ao Painel do Tinkercad. Clique em "Circuitos" à esquerda e selecione "Criar novo circuito". Vamos começar!

Você pode encontrar o arquivo completo em Circuitos TInkercad - Obrigado por verificar!

Etapa 1: adicionar alguns componentes

Você precisará de alguns componentes básicos. Esses incluem:

• Placa Arduino
• Tábua de pão

Adicione-os pesquisando-os e clicando e arrastando-os para a área do meio.

Coloque a placa de ensaio sobre o Arduino. Isso torna mais fácil visualizar as conexões posteriormente.

Etapa 2: uma nota sobre placas de ensaio

Uma placa de ensaio é um dispositivo muito útil para prototipagem rápida. Nós o usamos para conectar componentes. Algumas coisas a serem observadas.

1. Os pontos são conectados verticalmente, mas a linha no meio separa essa conexão das colunas superior e inferior.
2. As colunas não são conectadas da esquerda para a direita, como na linha. Isso significa que todos os componentes devem ser conectados nas colunas, em vez de posicioná-los verticalmente.
3. Se você precisar usar botões ou interruptores, conecte-os ao longo do intervalo no meio. Visitaremos isso em um tutorial posterior.

Etapa 3: adicionar dois sensores

Os dois sensores que estamos usando são um sensor fotossensível e um sensor de temperatura.

Esses sensores avaliam a luz e a temperatura. Usamos o Arduino para ler o valor e exibi-lo no monitor Serial do Arduino.

Procure e adicione os dois sensores. Certifique-se de que eles estejam posicionados nas colunas da placa de ensaio. Coloque espaço suficiente entre eles para tornar mais fácil vê-los.

Etapa 4: sensor fotossensível

1. Para o sensor fotossensível, adicione um fio do pino de 5 V no Arduino à mesma coluna da perna direita na peça da placa de ensaio. Mude a cor do fio para vermelho.
2. Conecte a perna esquerda por meio do pino na mesma coluna ao pino A0 (A-zero) no Arduino. Este é o pino analógico, que usaremos para ler o valor do sensor. Pinte este fio de amarelo ou algo diferente de vermelho ou preto.

3. Coloque um resistor (pesquise e clique e arraste) no quadro. Isso completa o circuito e protege o sensor e o pino.

   • Vire-o para que passe pelas colunas.
   • Conecte uma perna à coluna da perna direita na placa de ensaio

   • Coloque um fio da outra extremidade do resistor até o solo

     Mude a cor do fio para preto

4. Verifique todas as conexões. Se algo não estiver no lugar certo, isso não funcionará corretamente.

Etapa 5: iniciar o código

Vejamos o código deste componente.

Primeiro, olhe para a terceira imagem nesta etapa. Ele contém algum código com duas funções:

void setup ()

void loop ()

Em C ++, todas as funções fornecem seu tipo de retorno, depois o nome e as duas chaves que podem ser usadas para passar argumentos, geralmente como variáveis. Nesse caso, o tipo de retorno é nulo ou nada. O nome é configurado e a função não aceita argumentos.

A função de configuração é executada uma vez quando o Arduino é inicializado (quando você o conecta ou conecta as baterias).

A função de loop é executada em um loop constante a partir do milissegundo em que a função de configuração é concluída.

Tudo o que você colocar na função de loop será executado quando o Arduino for executado. Tudo fora disso só será executado quando chamado. Como se definíssemos e chamássemos outra função fora do loop.

Tarefa

Abra o painel Código com o botão no Tinkercad. Altere a lista suspensa Blocos para Texto. Concorde com a caixa de aviso que aparece. Agora, exclua tudo o que você vê, exceto o texto na terceira imagem nesta etapa.

Variáveis

Para começar, precisamos atribuir algumas variáveis para tornar nosso código realmente eficiente.

As variáveis são como baldes que podem conter apenas um objeto (C ++ é o que chamamos de orientação a objetos). Sim, temos matrizes, mas essas são variáveis especiais e falaremos sobre elas mais tarde. Quando atribuímos uma variável, precisamos dizer a ela de que tipo ela é e, em seguida, atribuir um valor a ela. Se parece com isso:

int someVar = A0;

Então, atribuímos uma variável e demos a ela o tipo int. Um int é um inteiro ou um número inteiro.

"Mas você não usou um número inteiro!", Ouço você dizer. Isso é verdade.

O Arduino faz algo especial para nós, então podemos usar A0 como um inteiro, porque em outro arquivo ele define A0 como um inteiro, então podemos usar a constante A0 para nos referirmos a este inteiro sem precisar saber o que é. Se apenas digitássemos 0, nos referiríamos ao pino digital na posição 0, o que não funcionaria.

Portanto, para o nosso código, escreveremos uma variável para o sensor que anexamos. Embora eu recomende dar a ele um nome simples, isso é com você.

Seu código deve ser assim:

int lightSensor = A0;

void setup () {} void loop () {}

Agora, vamos dizer ao Arduino como lidar com o sensor naquele pino. Executaremos uma função dentro da configuração para definir o modo de pino e dizer ao Arduino onde procurá-lo.

int lightSensor = A0;

void setup () {pinMode (lightSensor, INPUT); } void loop () {}

a função pinMode informa ao Arduino que o pino (A0) será usado como um pino INPUT. Observe o camelCaseUsed (veja cada primeira letra é uma maiúscula, já que tem saliências, portanto … camel …!) Para as variáveis e nomes de funções. Esta é uma convenção e bom para se acostumar.

Finalmente, vamos usar a função analogRead para obter alguns dados.

int lightSensor = A0;

void setup () {pinMode (lightSensor, INPUT); } void loop () {int reading = analogRead (lightSensor); }

Você verá que armazenamos a leitura em uma variável. Isso é importante porque precisamos imprimi-lo. Vamos usar a biblioteca Serial (uma biblioteca é um código que podemos adicionar ao nosso código para tornar as coisas mais rápidas para escrevermos, apenas chamando-a por sua definição) para imprimir isso no monitor serial.

int lightSensor = A0;

void setup () {// Define os modos dos pinos pinMode (lightSensor, INPUT); // Adiciona a biblioteca serial Serial.begin (9600); } void loop () {// Lê o sensor int reading = analogRead (lightSensor); // Imprime o valor no monitor Serial.print ("Light:"); Serial.println (leitura); // atrasa o próximo loop em 3 segundos delay (3000); }

Algumas coisas novas! Primeiro, você verá estes:

// Este é um comentário

Usamos comentários para dizer a outras pessoas o que nosso código está fazendo. Você deve usá-los com frequência. O compilador não os lerá e os converterá em código.

Agora, também adicionamos a biblioteca Serial com a linha

Serial.begin (9600)

Este é um exemplo de função que recebe um argumento. Você chamou a biblioteca Serial e então executou uma função (sabemos que é uma função por causa das chaves) e passou um inteiro como um argumento, configurando a função Serial para operar a 9600baud. Não se preocupe com o motivo - apenas saiba que funciona, por enquanto.

A próxima coisa que fizemos foi imprimir no monitor serial. Usamos duas funções:

// Este imprime na série sem quebra de linha (uma entrada no final)

Serial.print ("Light:"); // Este coloca a quebra de linha, então cada vez que lemos e escrevemos, ela entra em uma nova linha Serial.println (leitura);

O que é importante ver é que cada um tem um propósito separado. Certifique-se de que suas strings usem aspas duplas e que você deixe o espaço após os dois pontos. Isso ajuda a legibilidade para o usuário.

Por fim, usamos a função de atraso, para desacelerar nosso loop e fazê-lo ler apenas uma vez a cada três segundos. Isso é escrito em milhares de segundos. Altere para ler apenas uma vez a cada 5 segundos.

Excelente! Vamos lá!

Etapa 6: Simulação

Sempre verifique se as coisas funcionam executando a simulação. Para este circuito, você também precisará abrir o simulador para verificar se ele funciona e verificar seus valores.

Inicie a simulação e verifique o monitor serial. Altere o valor do sensor de luz clicando nele e alterando o valor usando o controle deslizante. Você deve ver a mudança de valor no monitor serial também. Do contrário, ou se você obtiver erros ao pressionar o botão Iniciar simulação, volte com cuidado e verifique todo o seu código.

• Concentre-se nas linhas indicadas na janela de depuração vermelha que será apresentada a você.
• Se seu código estiver correto e a simulação ainda não funcionar, verifique sua fiação.
• Recarregue a página - você pode ter um erro de sistema / servidor não relacionado.
• Sacuda o punho para o computador e verifique novamente. Todos os programadores fazem isso. Tudo. O. Tempo.

Etapa 7: conecte o sensor de temperatura

Vou presumir que você está no caminho certo agora. Vá em frente e conecte o sensor de temperatura como a imagem sugere. Observe a colocação dos fios 5V e GND no mesmo espaço que os da luz. Isso está certo. É como um circuito paralelo e não causará problemas no simulador. Em um circuito real, você deve usar uma placa de breakout ou blindagem para fornecer melhor gerenciamento de energia e conexões.

Agora, vamos atualizar o código.

O código do sensor de temperatura

Isso é um pouco mais complicado, mas apenas porque temos que fazer algumas contas para converter a leitura. Não é tão ruim.

int lightSensor = A0;

int tempSensor = A1; void setup () {// Define os modos dos pinos pinMode (lightSensor, INPUT); // Adiciona a biblioteca serial Serial.begin (9600); } void loop () {// O sensor de temperatura // Criando duas variáveis em uma linha - oh eficiência! // Float var para armazenar uma tensão de float decimal, grausC; // Ler o valor do pino e convertê-lo em uma leitura de 0 - 5 // Essencialmente tensão = (5/1023 = 0,004882814); voltagem = (analogRead (tempSensor) * 0,004882814); // Converter para graus C graus C = (tensão - 0,5) * 100; // Imprimir no monitor serial Serial.print ("Temp:"); Serial.print (grausC); Serial.println ("oC"); // Lê o sensor int reading = analogRead (lightSensor); // Imprime o valor no monitor Serial.print ("Light:"); Serial.println (leitura); // atrasa o próximo loop em 3 segundos delay (3000); }

Fiz algumas atualizações no código. Vamos examiná-los individualmente.

Primeiro, adicionei a linha

int tempSensor = A1;

Assim como o lightSensor, preciso armazenar o valor em uma variável para facilitar mais tarde. Se eu tivesse que mudar a localização deste sensor (como religar a placa), então eu só teria que mudar uma linha de código, não pesquisar em toda a base de código para mudar o A0 ou A1, etc.

Em seguida, adicionamos uma linha para armazenar a leitura e a temperatura em um flutuador. Observe duas variáveis em uma linha.

tensão flutuante, graus C;

Isso é realmente útil porque reduz o número de linhas que tenho que escrever e acelera o código. No entanto, pode ser mais difícil encontrar erros.

Agora, faremos a leitura e o armazenaremos, em seguida, converteremos em nosso valor de saída.

voltagem = (analogRead (tempSensor) * 0,004882814);

graus C = (tensão - 0,5) * 100;

Essas duas linhas parecem difíceis, mas na primeira estamos fazendo a leitura e multiplicando por 0,004 … porque converte 1023 (a leitura analógica retorna este valor) em uma leitura de 5.

A segunda linha multiplica essa leitura por 100 para mover o ponto decimal. Isso nos dá a temperatura. Arrumado!

Etapa 8: Teste e Verificação

Todas as coisas estão indo de acordo com o plano, você deve ter um circuito funcionando. Teste executando a simulação e usando o monitor serial. Se você tiver erros, verifique, verifique novamente e balance o punho.

Você fez isso? Compartilhe e conte-nos sua história!

Este é o circuito final embutido para que você possa reproduzir / testar a criação final. Obrigado por completar o tutorial!