home Tecnologia de manufatura Equipamentos de Fabricação
Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

Neste tutorial Arduino, aprenderemos a usar o módulo de comunicação serial sem fio HC-12, capaz de estabelecer comunicação sem fio de longo alcance entre múltiplas placas Arduino, com distâncias de até 1,8 km. Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo para mais detalhes.

Visão Geral

Para este tutorial, preparei dois exemplos básicos explicando como conectar o módulo HC-12 e fazer uma comunicação básica entre dois Arduinos, e um exemplo adicional onde, usando um sensor acelerômetro no primeiro Arduino, controlo sem fio a posição de um motor de passo no segundo Arduino.

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

Módulo de Comunicação Sem Fio HC-12

Vamos examinar mais de perto o módulo de porta serial sem fio HC-12. Aqui estão algumas especificações:

  • Sua banda de frequência de trabalho varia de 433,4 MHz a 473,0 MHz
  • Possui um total de 100 canais com espaçamento de 400 KHz entre cada canal
  • Potência de transmissão varia de -1dBm (0,79mW) a 20dBm (100mW)
  • Sensibilidade de recepção varia de -117dBm (0,019pW) a -100dBm (10pW)

Esses valores dependem da taxa de baud serial e over-the-air selecionada, conforme mostrado na tabela.

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

O módulo HC-12 possui um microcontrolador que não precisa ser programado pelo usuário. Para configurar o módulo, simplesmente usamos comandos AT, que podem ser enviados a partir de um Arduino, PC ou qualquer outro microcontrolador usando a porta serial. Para entrar no modo de comando AT, basta definir o pino "Set" do módulo para nível lógico baixo.

Arduino e HC-12

Agora, vamos conectar o módulo HC-12 ao Arduino e fazer o primeiro exemplo. Aqui está o esquema do circuito. A tensão de operação do módulo varia de 3,2 V a 5,5 V e, para um funcionamento mais estável, recomenda-se usar um capacitor de desacoplamento e uma fonte de alimentação externa. No entanto, usei a USB do PC como alimentação para todos os três exemplos neste tutorial e não tive problemas.

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

Conectei o primeiro módulo a um Arduino UNO e o segundo a um Arduino MEGA, mas você pode usar qualquer placa que desejar.

Você pode obter os componentes necessários para este tutorial Arduino nos links abaixo:

  • Módulo de Comunicação Sem Fio HC-12
  • Placa Arduino
  • Protoboard e Jumpers

Exemplo 01 – Código Arduino

Aqui está o código Arduino para o primeiro exemplo, uma comunicação básica entre os dois módulos usando o Monitor Serial.

/* Comunicação Sem Fio de Longo Alcance Arduino usando HC-12 Exemplo 01 por Dejan Nedelkovski, www.HowToMechatronics.com */
#include <SoftwareSerial.h>
SoftwareSerial HC12(10, 11); // Pino TX do HC-12, Pino RX do HC-12

void setup() {
  Serial.begin(9600); // Porta serial para o computador
  HC12.begin(9600);   // Porta serial para o HC12
}

void loop() {
  while (HC12.available()) { // Se HC-12 tem dados
    Serial.write(HC12.read()); // Envia os dados para o Monitor Serial
  }
  while (Serial.available()) { // Se Monitor Serial tem dados
    HC12.write(Serial.read()); // Envia esses dados para o HC-12
  }
}

O mesmo código é usado para ambos os Arduinos. Podemos conectar os dois Arduinos em dois computadores separados, mas também podemos usar um único computador.

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

Nesse caso, uma vez conectado o primeiro Arduino ao computador, precisamos selecionar o modelo e a porta COM e fazer upload do código para o Arduino. Em seguida, conectamos o segundo Arduino e precisamos iniciar o Arduino IDE novamente para poder selecionar a outra porta COM à qual nosso segundo Arduino está conectado, e então fazer upload do mesmo código.

Então, uma vez que temos os dois Arduino IDEs rodando, podemos iniciar os monitores seriais e testar se a comunicação funciona corretamente. Tudo o que digitarmos no monitor serial será enviado de um para o outro Arduino.

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

Como o código funciona: Quando digitamos algo no monitor serial e clicamos no botão Enviar, no primeiro Arduino, o loop while com a função Serial.available() se tornará verdadeiro e, usando a função HC12.write(), enviaremos os dados do monitor serial para o módulo HC-12. Este módulo transferirá os dados sem fio para o segundo módulo HC-12, então no segundo Arduino o loop while com a função HC12.available() se tornará verdadeiro e, usando a função Serial.write(), os dados serão enviados para o monitor serial.

Podemos usar o mesmo código para enviar comandos AT e configurar os parâmetros do módulo. Tudo o que precisamos fazer é conectar o pino "Set" do módulo ao GND ou a qualquer pino digital do Arduino e definir o pino para nível lógico baixo.

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

Para testar se entramos com sucesso no modo, no monitor serial podemos digitar "AT" e devemos obter uma mensagem de resposta "OK". Existem um total de 12 comandos AT, usados para alterar vários parâmetros como taxa de baud, canal, potência de transmissão, etc. Por exemplo, se digitarmos "AT+B38400", a taxa de baud do módulo será definida para 38400.

Comandos AT:

1. AT – Comando de teste.

Exemplo: Envie "AT" para o módulo, e o módulo retorna "OK".

2. AT+Bxxxx – Altera a taxa de baud da porta serial.

Taxas de baud disponíveis: 1200 bps, 2400 bps, 4800 bps, 9600 bps, 19200 bps, 38400 bps, 57600 bps e 115200 bps. Padrão: 9600 bps.

Exemplo: Envie "AT+B38400" para o módulo, e o módulo retorna "OK+B19200".

3. AT+Cxxxx – Altera o canal de comunicação sem fio, de 001 a 100.

Padrão: Canal 001, com frequência de trabalho de 433,4 MHz. Cada canal seguinte é 400 KHz mais alto.

Exemplo: Se quisermos definir o módulo para o canal 006, precisamos enviar o comando "AT+C006" para o módulo, e o módulo retornará "OK+C006". A nova frequência de trabalho será 435,4 MHz.

Exemplo 02

Agora, vamos para o segundo exemplo. Aqui usaremos dois botões para selecionar diferentes canais de comunicação e ver um método diferente de armazenar os dados recebidos.

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

Nota: Os pinos "Set" de ambos os módulos HC-12 estão conectados aos pinos 6 dos dois Arduinos e os dois botões, no primeiro Arduino, aos pinos 4 e 3.

Código do Primeiro Arduino:

/* Arduino Comunicação Sem Fio de Longo Alcance usando HC-12 Exemplo 02 - Mudança de canais usando botões - Lado dos botões por Dejan Nedelkovski, www.HowToMechatronics.com */
#include <SoftwareSerial.h>
#define setPin 6
#define button1 4
#define button2 3
SoftwareSerial HC12(10, 11); // Pino TX do HC-12, Pino RX do HC-12
byte incomingByte;
String readBuffer = "";
int button1State = 0;
int button1Pressed = 0;
int button2State = 0;
int button2Pressed = 0;

void setup() {
  Serial.begin(9600); // Abre porta serial para o computador
  HC12.begin(9600);   // Abre porta serial para HC12
  pinMode(setPin, OUTPUT);
  pinMode(button1, INPUT);
  pinMode(button2, INPUT);
  digitalWrite(setPin, HIGH); // HC-12 modo normal, transparente
}

void loop() {
  // ==== Armazenando os dados recebidos em uma variável String
  while (HC12.available()) {
    incomingByte = HC12.read();
    readBuffer += char(incomingByte);
  }
  delay(100);

  // ==== Enviando dados de um HC-12 para outro via Monitor Serial
  while (Serial.available()) {
    HC12.write(Serial.read());
  }

  // ==== Se botão 1 pressionado, define canal 01
  button1State = digitalRead(button1);
  if (button1State == HIGH && button1Pressed == LOW) {
    button1Pressed = HIGH;
    delay(20);
  }
  if (button1Pressed == HIGH) {
    HC12.print("AT+C001"); // Envia comando AT para o outro módulo
    delay(100);
    digitalWrite(setPin, LOW);  // Define HC-12 no modo comando AT
    delay(100);
    HC12.print("AT+C001"); // Envia comando AT para HC-12
    delay(200);
    while (HC12.available()) {
      Serial.write(HC12.read());
    }
    Serial.println("Canal alterado com sucesso");
    digitalWrite(setPin, HIGH); // Sai do modo comando AT
    button1Pressed = LOW;
  }

  // ==== Se botão 2 pressionado, define canal 02
  button2State = digitalRead(button2);
  if (button2State == HIGH && button2Pressed == LOW) {
    button2Pressed = HIGH;
    delay(100);
  }
  if (button2Pressed == HIGH) {
    HC12.print("AT+C002");
    delay(100);
    digitalWrite(setPin, LOW);
    delay(100);
    HC12.print("AT+C002");
    delay(200);
    while (HC12.available()) {
      Serial.write(HC12.read());
    }
    Serial.println("Canal alterado com sucesso");
    digitalWrite(setPin, HIGH);
    button2Pressed = LOW;
  }

  checkATCommand();
  readBuffer = "";
}

// ==== Função personalizada - Verifica se recebemos um comando AT via Monitor Serial
void checkATCommand() {
  if (readBuffer.startsWith("AT")) {
    digitalWrite(setPin, LOW);
    delay(200);
    HC12.print(readBuffer);
    delay(200);
    while (HC12.available()) {
      Serial.write(HC12.read());
    }
    digitalWrite(setPin, HIGH);
  }
}

Código do Segundo Arduino:

/* Arduino Comunicação Sem Fio de Longo Alcance usando HC-12 Exemplo 02 - Mudança de canais usando botões por Dejan Nedelkovski, www.HowToMechatronics.com */
#include <SoftwareSerial.h>
#define setPin 6
SoftwareSerial HC12(10, 11);
byte incomingByte;
String readBuffer = "";

void setup() {
  Serial.begin(9600);
  HC12.begin(9600);
  pinMode(setPin, OUTPUT);
  digitalWrite(setPin, HIGH); // HC-12 modo normal
}

void loop() {
  while (HC12.available()) {
    incomingByte = HC12.read();
    readBuffer += char(incomingByte);
  }
  delay(100);

  while (Serial.available()) {
    HC12.write(Serial.read());
  }

  // === Se botão 1 pressionado, define canal 01
  if (readBuffer == "AT+C001") {
    digitalWrite(setPin, LOW);
    delay(100);
    HC12.print(readBuffer);
    delay(200);
    while (HC12.available()) {
      Serial.write(HC12.read());
    }
    Serial.println("Canal alterado com sucesso");
    digitalWrite(setPin, HIGH);
    readBuffer = "";
  }

  // === Se botão 2 pressionado, define canal 02
  if (readBuffer == "AT+C002") {
    digitalWrite(setPin, LOW);
    delay(100);
    HC12.print(readBuffer);
    delay(200);
    while (HC12.available()) {
      Serial.write(HC12.read());
    }
    Serial.println("Canal alterado com sucesso");
    digitalWrite(setPin, HIGH);
    readBuffer = "";
  }

  checkATCommand();
  readBuffer = "";
}

void checkATCommand() {
  if (readBuffer.startsWith("AT")) {
    digitalWrite(setPin, LOW);
    delay(100);
    HC12.print(readBuffer);
    delay(200);
    while (HC12.available()) {
      Serial.write(HC12.read());
    }
    digitalWrite(setPin, HIGH);
  }
}

Descrição dos códigos:

Primeiro, definimos os pinos e definimos o pino "Set" para nível lógico alto para que o módulo funcione no modo normal, transparente. Com o primeiro loop while, armazenamos os dados recebidos em uma variável String, para que possamos manipulá-los melhor.

// ==== Armazenando os dados recebidos em uma variável String
while (HC12.available()) {
  incomingByte = HC12.read();
  readBuffer += char(incomingByte);
}

Os dados recebidos sempre chegam um byte por vez. Por exemplo, se enviarmos a string "Teste123" do segundo Arduino, este loop while fará 7 iterações. A cada iteração, usando a função HC12.read(), leremos cada byte ou caractere recebido e o adicionaremos à variável String chamada "readBuffer".

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

Em seguida, vejamos como podemos mudar o canal de comunicação usando o primeiro botão. Se pressionarmos o primeiro botão, usando a função HC12.print(), enviaremos a string "AT+C001" para o módulo HC-12 ou para o segundo Arduino.

if (button1Pressed == HIGH) {
  HC12.print("AT+C001");
  delay(100);
  digitalWrite(setPin, LOW);
  delay(100);
  HC12.print("AT+C001");
  delay(200);
  while (HC12.available()) {
    Serial.write(HC12.read());
  }
  Serial.println("Canal alterado com sucesso");
  digitalWrite(setPin, HIGH);
  button1Pressed = LOW;
}

Quando esta string for recebida no segundo Arduino, definiremos o módulo HC-12 no modo comando AT e, em seguida, escreveremos a mesma string "AT+C001" nele, o que definirá o módulo para o canal de comunicação número um.

// No segundo Arduino
if (readBuffer == "AT+C001") {
  digitalWrite(setPin, LOW);
  delay(100);
  HC12.print(readBuffer);
  delay(200);
  while (HC12.available()) {
    Serial.write(HC12.read());
  }
  Serial.println("Canal alterado com sucesso");
  digitalWrite(setPin, HIGH);
  readBuffer = "";
}

Usamos o próximo loop while para imprimir a mensagem de resposta do módulo HC-12 se o canal foi alterado com sucesso.

while (HC12.available()) {
  Serial.write(HC12.read());
}

De volta ao primeiro Arduino, fazemos o mesmo procedimento de enviar o comando AT para o primeiro módulo HC-12. Da mesma forma, pressionando o segundo botão, definimos o canal de comunicação número dois. Assim, usando este método, podemos selecionar, a qualquer momento, com qual módulo HC-12 iremos comunicar.

No final, a função personalizada checkATCommand() verifica se a mensagem recebida é um comando AT, verificando se a string começa com "AT". Se sim, o módulo entra no modo comando AT e executa o comando.

void checkATCommand() {
  if (readBuffer.startsWith("AT")) {
    digitalWrite(setPin, LOW);
    delay(200);
    HC12.print(readBuffer);
    delay(200);
    while (HC12.available()) {
      Serial.write(HC12.read());
    }
    digitalWrite(setPin, HIGH);
  }
}

Comunicação Sem Fio HC-12: Controle de Motor de Passo usando Acelerômetro

Agora, vamos ver o terceiro exemplo. Aqui controlamos a posição do motor de passo no segundo Arduino, usando o módulo acelerômetro no primeiro Arduino.

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

O circuito também contém um microinterruptor para encontrar a posição inicial do motor de passo em 0 graus.

Construa Redes Arduino de Longo Alcance Confiáveis com o Módulo HC‑12

Você pode obter os componentes necessários para este exemplo nos links abaixo:

  • Módulo de Comunicação Sem Fio HC-12
  • Driver de Motor de Passo A4988
  • Motor de Passo NEMA 17
  • Placa Arduino
  • Protoboard e Jumpers
  • Placa GY-80 com Acelerômetro ADXL345

Nota: Já tenho tutoriais detalhados sobre como conectar e usar tanto o acelerômetro quanto o motor de passo, então para este exemplo explicarei apenas a parte do código do HC-12.

Primeiro Arduino – Código Transmissor:

/* Arduino Comunicação Sem Fio de Longo Alcance usando HC-12 Exemplo 03 - Controle de Motor de Passo usando Acelerômetro - Transmissor, Acelerômetro por Dejan Nedelkovski, www.HowToMechatronics.com */
#include <SoftwareSerial.h>
#include <Wire.h>
SoftwareSerial HC12(10, 11);
float angle;
int lastAngle = 0;
int count = 0;
int angleSum = 0;

//--- Endereços dos Registradores do Acelerômetro
#define Power_Register 0x2D
#define X_Axis_Register_DATAX0 0x32
#define X_Axis_Register_DATAX1 0x33
#define Y_Axis_Register_DATAY0 0x34
#define Y_Axis_Register_DATAY1 0x35
#define Z_Axis_Register_DATAZ0 0x36
#define Z_Axis_Register_DATAZ1 0x37

int ADXAddress = 0x53;
int X0, X1, X_out;
int Y0, Y1, Y_out;
int Z1, Z0, Z_out;
float Xa, Ya, Za;

void setup() {
  HC12.begin(9600);
  Wire.begin();
  Serial.begin(9600);
  delay(100);
  Wire.beginTransmission(ADXAddress);
  Wire.write(Power_Register);
  Wire.write(8); // Bit D3 alto para habilitar medição
  Wire.endTransmission();
}

void loop() {
  // Eixo X
  Wire.beginTransmission(ADXAddress);
  Wire.write(X_Axis_Register_DATAX0);
  Wire.write(X_Axis_Register_DATAX1);
  Wire.endTransmission();
  Wire.requestFrom(ADXAddress, 2);
  if (Wire.available() <= 2) {
    X1 = Wire.read();
    X1 = X1 << 8;
    X_out = X0 + X1;
    Xa = X_out / 256.0;
  }

  // Eixo Y
  Wire.beginTransmission(ADXAddress);
  Wire.write(Y_Axis_Register_DATAY0);
  Wire.write(Y_Axis_Register_DATAY1);
  Wire.endTransmission();
  Wire.requestFrom(ADXAddress, 2);
  if (Wire.available() <= 2) {
    Y0 = Wire.read();
    Y1 = Wire.read();
    Y1 = Y1 << 8;
    Y_out = Y0 + Y1;
    Ya = Y_out / 256.0;
  }

  // Combina valores X e Y para obter ângulo de 0 a 180 graus
  if (Y_out > 0) {
    angle = map(Y_out, 0, 256, 90, 0);
  } else if (Y_out < 0) {
    angle = map(Y_out, 256, 0, 90, 0);
    angle = 90 - angle;
  }
  if (X_out < 0 && Y_out < 0) {
    angle = 180;
  }
  if (X_out < 0 && Y_out > 0) {
    angle = 0;
  }

  // float para int
  int angleInt = int(angle);

  // Faz 100 leituras do acelerômetro e envia a média para resultado mais suave
  angleSum = angleSum + angleInt;
  count++;
  if (count >= 100) {
    angleInt = angleSum / 100;
    angleSum = 0;
    count = 0;

    // Mais suavização - envia novo ângulo apenas se diferir do anterior em +-2
    if (angleInt > lastAngle + 2 || angleInt < lastAngle - 2) {
      Serial.println(angleInt);
      String angleString = String(angleInt);
      // Envia valor do ângulo com marcador inicial "s" e final "e"
      HC12.print("s" + angleString + "e");
      delay(10);
      lastAngle = angleInt;
      angleSum = 0;
      count = 0;
    }
  }
}

Segundo Arduino – Código Receptor:

/* Arduino Comunicação Sem Fio de Longo Alcance usando HC-12 Exemplo 03 - Controle de Motor de Passo usando Acelerômetro - Receptor, Motor de Passo por Dejan Nedelkovski, www.HowToMechatronics.com */
#include <SoftwareSerial.h>
SoftwareSerial HC12(10, 11);
char incomingByte;
String readBuffer = "";

// define pinos
const int dirPin = 4;
const int stepPin = 3;
const int button = 2;

int currentAngle = 0;
int lastAngle = 0;
int rotate = 0;

void setup() {
  Serial.begin(9600);
  HC12.begin(9600);
  pinMode(dirPin, OUTPUT);
  pinMode(stepPin, OUTPUT);
  pinMode(button, INPUT_PULLUP);
  delay(10);
  digitalWrite(dirPin, HIGH);

  boolean startingPosition = true;
  while (startingPosition) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(200);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(200);
    if (digitalRead(button) == LOW) {
      startingPosition = false;
    }
  }
  delay(100);
}

void loop() {
  readBuffer = "";
  boolean start = false;

  // Lê o ângulo recebido
  while (HC12.available()) {
    incomingByte = HC12.read();
    delay(5);
    if (start == true) {
      if (incomingByte != 'e') {
        readBuffer += char(incomingByte);
      } else {
        start = false;
      }
    } else if (incomingByte == 's') {
      start = true;
    }
  }

  // Converte string para inteiro
  currentAngle = readBuffer.toInt();

  // Garante uso de ângulos entre 0 e 180
  if (currentAngle > 0 && currentAngle < 180) {
    // Converte valor do ângulo para passos (dependendo da resolução de passo selecionada)
    // Um ciclo = 200 passos, 180graus = 100 passos; Resolução: Décimo sexto passo x16
    currentAngle = map(currentAngle, 0, 180, 0, 1600);

    digitalWrite(dirPin, LOW);

    // Rotaciona o motor a quantidade de passos que difere da posição anterior
    if (currentAngle != lastAngle) {
      if (currentAngle > lastAngle) {
        rotate = currentAngle - lastAngle;
        for (int x = 0; x < rotate; x++) {
          digitalWrite(stepPin, HIGH);
          delayMicroseconds(400);
          digitalWrite(stepPin, LOW);
          delayMicroseconds(400);
        }
      }
      if (currentAngle < lastAngle) {
        rotate = lastAngle - currentAngle;
        digitalWrite(dirPin, HIGH);
        for (int x = 0; x < rotate; x++) {
          digitalWrite(stepPin, HIGH);
          delayMicroseconds(400);
          digitalWrite(stepPin, LOW);
          delayMicroseconds(400);
        }
      }
    }
    lastAngle = currentAngle;
  }
}

Descrição dos códigos:

Primeiro, definimos os pinos e inicializamos os módulos na seção setup. Em seguida, lemos os valores dos eixos X e Y do acelerômetro e os mapeamos para valores de 0 a 180 graus. Os valores vindos do acelerômetro podem às vezes ser instáveis ou tremer, então, para suavizar o resultado, usei o valor médio de cem leituras.

// Faz 100 leituras do acelerômetro e envia a média para resultado mais suave
angleSum = angleSum + angleInt;
count++;
if (count >= 100) {
  angleInt = angleSum / 100;
  angleSum = 0;
  count = 0;
  // Mais suavização - envia novo ângulo apenas se diferir do anterior em +-2
  if (angleInt > lastAngle + 2 || angleInt < lastAngle - 2) {
    Serial.println(angleInt);
    String angleString = String(angleInt);
    HC12.print("s" + angleString + "e");
    delay(10);
    lastAngle = angleInt;
    angleSum = 0;
    count = 0;
  }
}

Para uma suavização ainda maior, enviarei o novo valor do ângulo apenas se ele diferir do anterior em 2.

Note que ao enviar o ângulo para o módulo HC-12, também envio o caractere "s" no início e o caractere "e" no final, o que me ajudará ao receber os dados no segundo Arduino.

No segundo Arduino, esperamos até que o marcador de início "s" chegue, então lemos o valor do ângulo até que o marcador de fim "e" chegue. Dessa forma, temos certeza de que receberemos apenas o valor do ângulo.

// Lê o ângulo recebido
while (HC12.available()) {
  incomingByte = HC12.read();
  delay(5);
  if (start == true) {
    if (incomingByte != 'e') {
      readBuffer += char(incomingByte);
    } else {
      start = false;
    }
  } else if (incomingByte == 's') {
    start = true;
  }
}

Então, convertemos o valor para inteiro e mapeamos o valor de 0 a 1600 passos, o que corresponde à resolução de décimo sexto passo selecionada no driver de motor de passo A4988. Em seguida, rotacionamos o motor de passo para o ângulo atual.

Isso é tudo para este tutorial Arduino. Sinta-se à vontade para fazer qualquer pergunta na seção de comentários abaixo.

Processo de manufatura

  • Processo de manufatura
  • impressao 3D
  • Sistema de controle de automação
  • Tecnologia industrial
    1. Dominando Alcance de Comunicação Sem Fio: Como Potência, Taxa de Dados e Interferência Moldam Conectividade
    2. Como Sem Fio de Longo Alcance Alimentado por Bateria Está Transformando a Conectividade
    3. Crie Animações e Jogos Envolventes em LCD com Arduino UNO
    4. Gerador de Ondas JX – Oscilador DDS Compatível com Arduino com Display OLED
    5. Módulo GPS u-blox LEA‑6H 02: Guia de Integração com Arduino e Python
    6. Scanner IR de Temperatura Sem Fio – Arduino Nano com Bluetooth e MLX90614
    7. Python 3 para Arduino UNO: Controle de Comandos Fácil e Demo com LED
    8. Construa um Rádio FM Compacto com Arduino Nano e RDA5807M
    9. Sistema Avançado de Detecção de Quedas com Arduino, Windows IoT e Azure Cloud
    10. ArduRadio: Relógio Despertador DIY com Rádio FM Baseado em Arduino