Usando o Sensor de Efeito Hall US1881

Introdução

O sensor de efeito Hall US1881 é capaz de emitir um sinal de acordo com a polaridade de um ímã. Ele pode ser usado como uma chave eletrônica que mantém sua saída digital em nível lógico baixo, e ao detectar a polaridade de um campo magnético, sua saída digital assume o nível lógico alto.

Sabendo disso, podemos criar diversos projetos, tais como: sensor de deslocamento, detector de metais magnéticos, entre outros. Neste tutorial iremos desenvolver uma simples conexão com o Arduino para exibir o pólo do ímã que foi detectado na porta serial, e posteriormente um acionamento de cargas.

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard UNO R3

R$99.90

Cabo USB AB 1.50m

R$10.90

Sensor de Efeito Hall

R$6.90

LED 5mm Vermelho (10 unidades)

R$2.50

LED 5mm Azul (10 unidades)

R$2.60

Resistor 10kΩ - Pacote com 10 unidades

R$0.75

Resistor 300Ω - Pacote com 10 unidades

R$0.75

Protoboard 400 Pontos

R$7.50

WorkPlate 400 - Preta

R$14.90

Jumpers Macho-Macho x40 Unidades

R$7.90

Conceitos Teóricos

Magnetismo

Magnetismo se refere a todo fenômeno, ou conjunto de fenômenos, de atração ou repulsão de corpos que se caracteriza como uma força dipolar, ou seja, que possui dois pólos. No caso de corpos magnéticos, como ímãs, a força magnética é originada no pólo Norte, em direção ao pólo Sul. Essa força resulta em uma atração de corpos caso os pólos sejam opostos, ou seja, o pólo Norte irá atrair o pólo Sul, e vice versa. Consequentemente, para pólos iguais, os corpos tendem a se repelir.

Alguns materiais metálicos, como o próprio ferro, não são capazes de gerar uma força magnética, porém são atraídos por elas. No entanto, existem já alguns métodos para imantar esses materiais, de modo que os mesmos passem a ter uma força magnética para atração ou repulsão. Além disso, graças à eletricidade, é possível criar um campo magnético através da passagem de corrente elétrica. Este fenômeno é denominado eletromagnetismo.

Sensor de Efeito Hall

O US1881 é um circuito integrado que é capaz de operar como um sensor de efeito Hall, detectando a polaridade de um campo magnético. Ele é capaz de identificar o pólo do ímã, entrando em nível lógico alto quando identificado um pólo Norte, e em nível lógico baixo para um pólo Sul, como na imagem abaixo.

Vale lembrar que este sensor mantém o último estado lido, mesmo na ausência de um campo magnético. Ele irá apenas alterar o seu estado caso haja uma alteração na polaridade do campo lido.

Projeto Identificando Pólos do Ímã

Circuito

Monte o circuito conforme a figura abaixo. Note que colocamos um resistor pull-up de 10 kΩ entre os pinos "VCC" e "OUT", responsável por definir a tensão de referência do sinal em 5 V.

Código

Copie o código abaixo e carregue-o para sua placa.

/*******************************************************************************
* Sensor de Efeito Hall : Identificando Polos (v1.0)
*
* Impressao do polo identificado na porta serial.
*  
* Copyright 2020 RoboCore.
* Escrito por Matheus Cassioli (10/08/2019).
* Atualizado por Giovanni de Castro (15/01/2020).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

const int PINO_SENSOR = 4; // Pino 4 conectado ao sensor
int leitura_sensor; // Variavel que armazena o estado da saida do sensor

void setup(){
  pinMode(PINO_SENSOR, INPUT); // Pino conectado ao sensor configurado como entrada
  Serial.begin(9600); // Inicia a comunicacao serial
}

void loop(){
  leitura_sensor = digitalRead(PINO_SENSOR); // Le a saida do sensor e armazena na variavel
  if (leitura_sensor == HIGH){ // Se o sensor estiver em nivel alto
    Serial.println("NORTE"); // Imprime NORTE
  } else { // Se o sensor estivel em nivel baixo
    Serial.println("SUL"); // Imprime SUL
  }
  delay(500); // Tempo para atualizacao de informacoes
}

Entendendo o Código

No início do código, definimos o pino de conexão com o sensor (PINO_SENSOR), e também criamos variável leitura_sensor, responsável por armazenar o último estado do sensor.

const int PINO_SENSOR = 4; // Pino 4 conectado ao sensor
int leitura_sensor; // Variavel que armazena o estado da saida do sensor

Definimos o pino conectado ao sensor como uma entrada e, com o comando Serial.begin(9600), iniciamos a porta serial em 9600 bps.

pinMode(PINO_SENSOR, INPUT); // Pino conectado ao sensor configurado como entrada
Serial.begin(9600); // Inicia a comunicacao serial

No loop do programa, atribuímos à variável leitura_sensor a leitura digital do pino do sensor. Em seguida, utilizamos a lógica if (leitura_sensor == HIGH) para verificar se o estado lido do sensor está nível alto, e então, caso a condição seja verdadeira, imprimir na porta serial que foi identificado o pólo Norte do ímã. Caso contrário, com o comando else, verificamos se o estado lido do sensor está em nível baixo, identificando, portanto, o pólo Sul do ímã.

leitura_sensor = digitalRead(PINO_SENSOR); // Le a saida do sensor e armazena na variavel
if ( leitura_sensor == HIGH){ // Se o sensor estiver em nivel alto
  Serial.println("NORTE"); // Imprime NORTE
} else { // Se o sensor estivel em nivel baixo
  Serial.println("SUL"); // Imprime SUL
}

O Que Deve Acontecer

Separe um imã e abra o serial monitor em 9600 bps. Ao aproximar o ímã do sensor, ele irá imprimir o pólo que ele está identificando, como na imagem a seguir.

Projeto Acionando Cargas com Ímã

Agora que aprendemos como funciona o sensor de efeito Hall, podemos incrementar nosso projeto acionando cargas. No nosso caso, iremos utilizar dois LEDs, um para cada pólo do ímã. Lembrando que você pode usar diversas cargas, sendo elas, relés, motores, entre outros.

Circuito

Para o projeto utilizando LEDs, monte o circuito conforme a figura abaixo.

Código

O código abaixo é igual ao do projeto anterior, porém adicionando comandos de controle dos LEDs, portanto copie-o e carregue-o para sua placa.

/*******************************************************************************
* Sensor de Efeito Hall :  Acionando Cargas com Ima (v1.0)
*
* Impressao do polo do ima na porta serial e controle de LEDs.
*  
* Copyright 2020 RoboCore.
* Escrito por Matheus Cassioli (10/08/2019).
* Atualizado por Giovanni de Castro (15/01/2020).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

const int PINO_SENSOR = 4; // Pino 4 conectado ao sensor
const int PINO_LED_VERMELHO = 5; // Pino 5 conectado ao LED vermelho
const int PINO_LED_AZUL = 6; // Pino 6 conectado ao LED azul
  
int leitura_sensor; // Variavel que armazena o estado da saida do sensor

void setup() {
  Serial.begin(9600); // Inicia a comunicacao serial
  
  pinMode(PINO_SENSOR, INPUT); // Pino conectado ao sensor configurado como entrada
  pinMode(PINO_LED_VERMELHO, OUTPUT); // Pino conectado ao LED vermelho configurado como saida
  pinMode(PINO_LED_AZUL, OUTPUT); // Pino conectado ao LED azul configurado como saida

  // LEDs apagados
  digitalWrite(PINO_LED_VERMELHO, LOW);
  digitalWrite(PINO_LED_AZUL, LOW);
}

void loop() {
  leitura_sensor = digitalRead(PINO_SENSOR); // Le a saida do sensor e armazena na variavel

  if (leitura_sensor == HIGH) { // Le a saida do sensor e armazena na variavel
    Serial.println("NORTE - LED VERMELHO ACESO"); // Imprime NORTE
    digitalWrite(PINO_LED_VERMELHO, HIGH); // LED vermelho em nivel alto
    digitalWrite(PINO_LED_AZUL, LOW); // LED azul em nivel baixo
  } else {
    Serial.println("SUL - LED AZUL ACESO"); // Imprime SUL
    digitalWrite(PINO_LED_AZUL, HIGH); // LED azul em nivel alto
    digitalWrite(PINO_LED_VERMELHO, LOW); // LED vermelho em nivel baixo
  }

  delay(500); // Tempo para atualizacao de informacoes
}

Entendendo o Código

Primeiramente, definimos os pinos para controle dos LEDs (PINO_LED_VERMELHO e PINO_LED_AZUL). Depois, na configuração do código, definimos ambos como saída do microcontrolador. E então, como boas práticas da programação, iniciamos a execução do código com os pinos dos LEDs em nível lógico baixo.

const int PINO_LED_VERMELHO = 5; // Pino 5 conectado ao LED vermelho
const int PINO_LED_AZUL = 6; // Pino 6 conectado ao LED azul

pinMode(PINO_LED_VERMELHO, OUTPUT); // Pino conectado ao LED vermelho configurado como saida
pinMode(PINO_LED_AZUL, OUTPUT); // Pino conectado ao LED azul configurado como saida

// LEDs apagados
digitalWrite(PINO_LED_VERMELHO, LOW);
digitalWrite(PINO_LED_AZUL, LOW);

Assim como no código anterior, quando é identificado o nível alto na variável leitura_sensor, o LED vermelho acende e o LED azul se mantém em nível baixo, identificando assim o pólo Norte do ímã. Caso contrário, o LED vermelho apaga e o LED azul vai para nível alto, indicando o pólo Sul do ímã.

if (leitura_sensor == HIGH) { // Le a saida do sensor e armazena na variavel
  Serial.println("NORTE - LED VERMELHO ACESO"); // Imprime NORTE
  digitalWrite(PINO_LED_VERMELHO, HIGH); // LED vermelho em nivel alto
  digitalWrite(PINO_LED_AZUL, LOW); // LED azul em nivel baixo
} else {
  Serial.println("SUL - LED AZUL ACESO"); // Imprime SUL
  digitalWrite(PINO_LED_AZUL, HIGH); // LED azul em nivel alto
  digitalWrite(PINO_LED_VERMELHO, LOW); // LED vermelho em nivel baixo
}

O Que Deve Acontecer

Ao aproximar o ímã do sensor, caso seja detectado pólo Sul, o LED azul acende. Caso o sensor identifique o pólo Norte do ímã, o LED vermelho acende, como no GIF abaixo.

Resultado Final

Indo Além

Neste tutorial vimos como realizar a leitura do sensor de efeito Hall US1881, e o seu funcionamento básico, porém são inúmeras suas aplicações. Alguns encoders de motores DC comuns utilizam um sensor de efeito Hall para ler a polaridade de um imã acoplado ao eixo do motor, conforme ele rotaciona. Essa rotação gera pulsos na saída do sensor, que podem ser usados para determinar a velocidade de rotação do motor.

Utilizando o mesmo princípio do encoder, o Sensor de Fluxo de Água também utiliza um imã acoplado a um eixo e um sensor de efeito de Hall, para determinar a velocidade de rotação de uma hélice. Essa velocidade de rotação pode ser utilizada para calcular o fluxo de água que está passando por ele, assim como calcular o volume total já passado. Caso você queira ver e entender melhor como funciona e como utilizar este sensor de fluxo, acesse o nosso tutorial Primeiros Passos com o Sensor de Fluxo.