Sensores - LAICA-IFRN/Robotica GitHub Wiki
Um sensor de linha infravermelho funciona com base no princípio da reflexão, emitindo radiação infravermelha e captando o retorno dessa radiação. Diferentes quantidades de radiação são refletidas de volta ao sensor dependendo da superfície. O dispositivo possui um emissor e um receptor de sinais infravermelhos, bem como alguns sensores podem ter um trimpot para ajustar a precisão da intensidade luminosa. Pode ser usado para identificar objetos ou em robôs seguidores de linha, que combinam motores, sensores e inteligência artificial para percorrer percursos no menor tempo possível.
O sensor deve ser colocando na parte de baixo do robo, que deve ter pelo menos um sensor para conseguir seguir a linha. Vale salientar que cada sensor tem uma distancia para a detecção, sendo responsabilidade da equipe saber quais os limites de posicionamento e distância do sensor.
Alguns sensores podem ser utilizados de forma análogica e digital.
void setup() {
Serial.begin(9600);
pinMode(A0, INPUT); // initialize Right sensor as an inut
pinMode(A1, INPUT); // initialize Left sensor as as input
}
void loop() {
// Lendo Sensores
int LEFT_SENSOR = analogRead(A0);
int RIGHT_SENSOR = analogRead(A1);
Serial.print(LEFT_SENSOR); // Imprime na serial o valor do sensor esquerdo
Serial.print(" ");
Serial.println(RIGHT_SENSOR); // Imprime na serial o valor do sensor direito
// A partir daqui seria o código de atuação
}
O sensor ultrassônico HC-SR04 funciona com base no princípio de propagação de ondas sonoras, especificamente ondas de alta frequência que são inaudíveis para os seres humanos. Ele é utilizado para medir a distância entre o sensor e alguma superfície. Essa medição é feita a partir do tempo que a onda leva para se propagar até a superfície mais próxima, refletir e retornar ao sensor. Assim, como temos a velocidade de propagação do som e o tempo, é possível calcular a distância percorrida pela onda sonora.
O sensor deve ser posicionado no local que melhor atenda à finalidade do seu uso. Por exemplo, se o interesse do usuário é medir a altura de algum objeto, o sensor deve ser colocado em cima do objeto, com seu emissor de ondas voltado para o solo. Ou, se o objetivo é medir a distância entre um robô e uma parede à sua frente, o sensor precisa ser posicionado na vertical. A equipe deve se atentar à maneira de posicioná-lo, verificando se não há algo obstruindo a propagação do som. É importante ressaltar que o sensor em questão possui limitações, podendo medir distâncias entre 2 cm e 4 m.
// Definindo os pinos do sensor
const int trigPin = 2; // Pino TRIG
const int echoPin = 3; // Pino ECHO
void setup() {
// Inicializa a comunicação serial
Serial.begin(9600);
// Define os modos dos pinos
pinMode(trigPin, OUTPUT); // TRIG como saída
pinMode(echoPin, INPUT); // ECHO como entrada
}
void loop() {
// Inicializa o pino TRIG como baixo
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Emite um pulso de 10 microsegundos no TRIG
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// Leitura do tempo de retorno no pino ECHO
long duration = pulseIn(echoPin, HIGH);
// Calcula a distância em centímetros
long distance = duration * 0.034 / 2;
// Exibe a distância no Serial Monitor
Serial.print("Distância: ");
Serial.print(distance);
Serial.println(" cm");
}
O sensor RGB TCS34725 dispõe de um conjunto de fotodiodos que captam a luz refletida pela superfície, que está próxima ao sensor, e converte essa coloração para valores digitais, retornando valores para o sistema de cores RGB e para claridade, ou seja, a intensidade de vermelho, verde e azul. Dentro do sistema, a combinação deles resultam na cor e tonalidade observada pelo sensor.
Com finalidade na robótica, o sensor deve ser posicionado na parte inferior do robô com seus componentes elétricos voltados para a superfície que deseja fazer a leitura de cor, sendo responsabilidade da equipe conferir se o lugar fixado é próprio para a leitura desejada. Por se tratar de um sensor que utiliza da comunicação por canal I2C, é necessário fazer uso de pelo menos duas bibliotecas, uma para a comunicação entre sensor e arduino e outra para obtenção de dados do sensor.
#include <Wire.h> // Inclui a biblioteca Wire para comunicação I2C
#include <Adafruit_TCS34725.h> // Inclui a biblioteca para o sensor TCS34725
// Cria uma instância do sensor TCS34725
// Configura o tempo de integração para 50ms e ganho para 1x
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_1X);
void setup() {
Serial.begin(9600); // Inicia a comunicação serial a 9600 bps
Serial.println("Iniciando o sensor TCS34725...");
// Inicializa o sensor TCS34725
if (tcs.begin()) {
Serial.println("Sensor TCS34725 iniciado com sucesso!");
} else {
// Se o sensor não for encontrado, exibe uma mensagem de erro
Serial.println("Não foi possível encontrar o sensor TCS34725. Verifique a conexão.");
while (1); // Para o programa se o sensor não for encontrado
}
}
void loop() {
uint16_t r, g, b, c; // Variáveis para armazenar os valores de R, G, B e C
// Lê os valores brutos do sensor
tcs.getRawData(&r, &g, &b, &c);
// Imprime os valores de R, G e B no Serial Monitor
Serial.print("R: "); Serial.print(r); // Imprime o valor de R
Serial.print(" G: "); Serial.print(g); // Imprime o valor de G
Serial.print(" B: "); Serial.println(b); // Imprime o valor de B
delay(1000); // Espera 1 segundo antes da próxima leitura
}
Igualmente ao ultrassônico, os sensores a laser tem como objetivo medir as distancias de certos objetos. Diferente do ultrassônico, ele funciona a partir da emissão de uma onda luminosa modulada por um laser, que reflete no objeto a sua frente, para medi-lo. Quando a luz é refletida e recebida novamente pelo sensor, a partir do tempo decorrido entre envio e recebimento, é possível calcular a distância obtendo-o juntamente da velocidade em que a luz percorre o ambiente.
O mais indicado para o uso com finalidades robóticas é o sensor a laser Vl53l0x. Para poder integrá-lo ao arduino, utiliza-se a comunicação por I2C com as portas SCL e SDA. Além disso, para facilitar, é necessário o uso de bibliotecas para o sensor. A mais indicada é a biblioteca "Adafruit_VL53L0X". Em relaçao ao seu posicionamento, fica a critério da equipe decidir a posição que mais lhes convêm.
#include <Wire.h> // Inclui a biblioteca Wire para comunicação I2C
#include <Adafruit_VL53L0X.h> // Inclui a biblioteca Adafruit para o sensor VL53L0X
// Cria um objeto para o sensor VL53L0X
Adafruit_VL53L0X lox = Adafruit_VL53L0X();
void setup() {
Serial.begin(115200); // Inicializa a comunicação serial a 115200 bps
Serial.println("VL53L0X Laser Distance Sensor Test"); // Mensagem inicial
// Tenta inicializar o sensor
if (!lox.begin()) {
Serial.println("Falha ao encontrar o sensor VL53L0X!"); // Mensagem de erro se não encontrar o sensor
while (1) { delay(10); } // Para o programa aqui em caso de falha
}
Serial.println("Sensor VL53L0X encontrado!"); // Mensagem de sucesso
}
void loop() {
VL53L0X_RangingMeasurementData_t measure; // Estrutura para armazenar os dados da medição
// Realiza a medição de distância; 'false' evita imprimir a saída automaticamente
lox.rangingTest(&measure, false);
// Verifica se a medição é válida (RangeStatus diferente de 4)
if (measure.RangeStatus != 4) {
Serial.print("Distância (mm): "); // Imprime a distância medida
Serial.println(measure.RangeMilliMeter); // Mostra a distância em milímetros
} else {
Serial.println("Sensor fora de alcance"); // Mensagem se o sensor não conseguir medir
}
delay(100); // Espera 100 ms antes da próxima medição
}
O sensor acelerômetro, em especifico o MPU6050, funciona com dois parâmetros, na detecção de aceleração e velocidade angular do sensor nos 3 eixos (X, Y e Z), baseados na gravidade da terra. Uma vez que são obtidos esses parâmetros, é possível se calcular a inclinação do sensor e a sua rotação.
Para fins de robótica, o sensor pode ser fixado da forma que a equipe achar mais conveniente, sendo um ponto importante que essa fixação seja forte, para evitar que haja folgas e o referido componente venha a entregar valores imprecisos. Para projetos de iniciantes, é recomendado o uso da biblioteca "MPU6050_tockn.h" para arduino.ide.
tirar foto do robô quando voltar do recesso
O sensor citado utiliza da comunicação por I2C do microcontrolador.
#include <MPU6050_tockn.h> // Inclui a biblioteca "MPU6050_tockn", que facilita a interface com o sensor MPU6050
#include <Wire.h> // Inclui a biblioteca Wire para permitir a comunicação I2C
MPU6050 mpu6050(Wire); // Cria um objeto da classe MPU6050, que usará a comunicação I2C
void setup() {
Serial.begin(9600);
Wire.begin(); // Inicia a comunicação I2C
mpu6050.begin(); // Inicializa o sensor MPU6050
mpu6050.calcGyroOffsets(true); // Calibração do sensor para tomar como ponto 0 o estado inicial do sensor
}
void loop() {
mpu6050.update(); // Atualiza os valores lidos do sensor (acelerômetro e giroscópio)
// Exibe o ângulo de inclinação (em graus) nos eixos X, Y e Z calculado a partir dos dados do giroscópio
Serial.print("angleX : ");
Serial.print(mpu6050.getAngleX()); // Obtém o ângulo calculado no eixo X
Serial.print("\tangleY : ");
Serial.print(mpu6050.getAngleY()); // Obtém o ângulo calculado no eixo Y
Serial.print("\tangleZ : ");
Serial.println(mpu6050.getAngleZ()); // Obtém o ângulo calculado no eixo Z
}