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
}
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.
Obs.: Cada tipo de sensor acima possui um tipo de integração ao arduino diferente.
#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
}