Unidades
1. Introdução à Inteligência Artificial em Mecatrônica, Segurança e Estrutura de Verificação 2. Inteligência Artificial em Robótica e Controle de Movimento 3. Sistemas Embarcados e Geração de Código Microcontrolador 4. Fusão de sensores e integração de dados IoT 5. Algoritmos de controle: ajuste com suporte de PID e IA 6. Automação Industrial e Programação PLC 7. Design e Simulação Baseados em Modelo 8. Manutenção Preditiva 9. Visão mecânica e controle de qualidade
Unidade 3 / 9

Sistemas Embarcados e Geração de Código Microcontrolador

Ganhos:

  • Capacidade de gerar código incorporado dado registro e contexto de hardware para Arduino/STM32/ESP32 com IA
  • Capacidade de reconhecer e corrigir padrões incorporados, como interrupções, temporizadores e loops sem bloqueio na saída de IA
  • Capacidade de revisar o código gerado em termos de memória, tempo real e segurança antes de carregá-lo no hardware

Na mecatrônica, o microcontrolador é onde as ideias encontram o mundo físico. Cartões como Arduino, STM32, ESP32; ele lê sensores, aciona atuadores, comunica-se e faz tudo isso com memória limitada, poder de processamento limitado e requisitos rígidos de temporização. A inteligência artificial é muito útil neste campo: ela pode extrair configurações de registro com base na folha de dados de um sensor, codificar um protocolo de comunicação, definir uma interrupção de temporizador. Mas os sistemas incorporados são uma das áreas onde a IA produz mais “falsidades convincentes”; porque os endereços de registro, as máscaras de bits e o comportamento de temporização são específicos da placa e um erro de bit interrompe todo o comportamento. Nesta unidade, abordamos como incorporar código gerado com IA e como revisá-lo antes de carregá-lo no hardware.

Diferença de código incorporado de software puro

Um programa de desktop possui bastante memória, sistema operacional e facilidade de depuração. O código incorporado não possui a maioria destes:

Tamanho

área de trabalho

sistema embarcado

memória

Nível de GB

Nível KB (por exemplo, 2 KB de RAM)

tempo

Geralmente flexível

Apertado, em tempo real

depuração

Fácil (depurador, log)

Difícil (JTAG, serial, LED)

Resultado do erro

O programa trava

O atuador/hardware pode estar danificado

acesso a recursos

Resumos de sistema operacional

Acesso direto ao Cadastro

Essas diferenças determinam seus critérios para avaliar a saída de IA: uso de memória, tempo real (sem bloqueio) e precisão do registro de hardware estão sempre no topo da sua lista de verificação.

Código bloqueador vs não bloqueador

O erro mais comum cometido por iniciantes (e frequentemente cometido pela IA) é o uso de delay(). delay(1000) bloqueia o processador por 1 segundo; Durante este período, nenhum outro sensor pode ser lido, nenhum botão pode ser controlado. Isso é inaceitável em mecatrônica. Em vez disso, é usado um padrão sem bloqueio baseado em milis().

// RUIM: bloqueador -- o processador não pode realizar nenhum outro trabalho por 1 segundo void loop() { digitalWrite(LED, HIGH); atraso(1000); // tudo para digitalWrite(LED, LOW); atraso(1000); // Um ​​botão de emergência não pode ser lido neste momento!}// BOM: sem bloqueio -- o loop não está bloqueado, outras tarefas são executadas if (nowMs - previousMs >= interval) { previousMs = nowMs; ledStatus = !ledStatus; digitalWrite(LED, ledStatus); } buttonVerificar(); // pode ser executado em todos os ciclos sensorRead(); //pode ser executado em qualquer loop}

O padrão sem bloqueio é a base da mecatrônica embarcada: a malha de controle flui continuamente, nenhuma tarefa bloqueia outra. Dizer à IA para "não usar atraso, escrever sem bloqueio baseado em milis" ao escrever código melhora diretamente a qualidade da saída.

Dica: Procure atraso (no código incorporado da IA. Se você observar um atraso no circuito de controle principal, na maioria das vezes esse código não é adequado para um sistema em tempo real e deve ser reescrito.

Interrupções e temporizadores

Capturamos eventos de tempo crítico (pulso do codificador, botão, amostragem periódica) com interrupções em vez de esperar no loop principal. A rotina de interrupção (ISR) deve ser escrita de forma curta e cuidadosa: sem atrasos, Serial.print ou cálculos longos nela; Variáveis compartilhadas são marcadas como voláteis.

volátil longo encoderCounter = 0; // ISR e loop são compartilhados -> condição volátil void enkoderISR() { // ISR curto: apenas conte, não faça outro trabalho if (digitalRead(ENC_B)) enkoderCounter++; else encoderCounter--;}void setup() { pinMode(ENC_A, INPUT_PULLUP); pinMode(ENC_B, INPUT_PULLUP); attachmentInterrupt(digitalPinToInterrupt(ENC_A), enkoderISR, RISING);}void loop() { contador longo; noInterrupções(); //interrupções curtas para leitura atômica counter = encoderCounter; interrompe(); //transacione com segurança com o contador...}

Três pontos críticos neste exemplo são onde a IA muitas vezes falha: (1) o encoderCounter compartilhado deve ser `volátil` ou a otimização do compilador perderá atualizações; (2) o ISR deve ser curto; (3) Ao ler uma variável multibyte no loop principal, as interrupções para leitura atômica devem ser fechadas por um curto período de tempo, caso contrário o ISR pode intervir durante a leitura e o valor meio/corrompido pode ser lido (condição de corrida). Certifique-se de verificar se esses três estão presentes no código AI.

Precisão de registro e folha de dados

A IA pode deturpar de maneira confiável o endereço de registro de um sensor ou o bit de configuração de um MCU. Por exemplo, o registro de gerenciamento de energia de uma IMU MPU6050 é 0x6B; Se a IA der isso como 0x6A, o código é compilado, parece funcionar, mas o sensor não acorda. Tais erros são detectados apenas quando comparados com a ficha técnica.

// Ativação do MPU6050: de acordo com a folha de dados PWR_MGMT_1 = 0x6B, valor 0x00#define MPU_ADDR 0x68#define PWR_MGMT_1 0x6B // <-- VERIFY from datasheetWire.beginTransmission(MPU_ADDR);Wire.write(PWR_MGMT_1);Wire.write(0x00); // acorda do modo de suspensão modeWire.endTransmission(true);

Atenção: Verifique cada endereço de registro, máscara de bits e endereço I2C/SPI fornecidos pela AI na folha de dados. Esses valores são específicos do cartão e do chip; O valor que a IA “lembra” pode ser de outra revisão do chip. Registro incorreto leva silenciosamente a comportamento incorreto.

Alerta Fraco/Prompt Forte

FRACO: "Leia o sensor de temperatura no ESP32." no primeiro comentário. Por motivos de memória, use char buffer em vez de String."

Alerta poderoso; Fornece o chip, estrutura, sensor, protocolo, pino, padrão de amostragem, status de erro e restrição de memória. Desta forma, o resultado é verificável e realista.

Lista de verificação de revisão para código incorporado

Antes de carregar a saída do AI, passe-a por esta lista:

  1. Bloqueio: Há atraso ou bloqueio longo no loop principal?
  2. volátil: as variáveis ​​compartilhadas com o ISR são voláteis?
  3. Acesso atômico: a variável compartilhada multibyte é segura para leitura?
  4. Cadastre-se: Os endereços e máscaras de bits são compatíveis com a ficha técnica?
  5. Memória: String, matrizes grandes, a recursão cria estouro no nível de KB?
  6. Tratamento de erros: Os erros de leitura do sensor e os tempos limite de comunicação são tratados?
  7. Partida segura: As saídas do atuador estão colocadas em estado seguro (passivo) na partida?

Mini Estojo

O engenheiro de sistemas embarcados Baran faz com que a IA escreva o código que lê a IMU de um drone. O código é compilado e parece funcionar, mas os valores dos ângulos não têm sentido. Baran aplica a lista de verificação: compara os endereços do registro com a folha de dados e descobre que a IA gera incorretamente o registro de configuração do giroscópio (0x1A em vez de 0x1B), portanto a escala de sensibilidade está errada. Depois de corrigidos, os valores se estabilizam. Então delay(10) avisos no loop principal; converter isso para uma estrutura baseada em milissegundos, porque o bloqueio do circuito de controle de vôo é inaceitável. Finalmente, ele vê que a variável do contador compartilhado não é volátil e a adiciona. AI deu o esqueleto rapidamente; Mas a lista de revisão detectou três erros distintos: registro, bloqueio e volátil, e o hardware não corria nenhum risco.

Erros Comuns

  • Eliminando a resposta em tempo real usando delay() no circuito de controle principal.
  • Evite tornar a variável compartilhada com o ISR volátil e sofrer corrupção silenciosa de dados.
  • Lendo uma variável compartilhada multibyte de forma não atômica e gerando uma condição de corrida.
  • Não verificar as máscaras de registro/bit fornecidas pela AI com a folha de dados.
  • Criando um estouro de memória usando Strings e grandes arrays em RAM limitada.
  • Esquecer de proteger inicialmente as saídas do atuador.

Em resumo

  • Código incorporado; Ele opera com memória limitada, tempo apertado e acesso direto ao registro.
  • No loop principal, um padrão sem bloqueio baseado em milissegundos é usado em vez de atraso.
  • O ISR é mantido curto; variáveis ​​compartilhadas devem ser voláteis e acessadas de forma atômica.
  • Endereços de registro e máscaras de bits são sempre verificados na folha de dados; A IA pode estar errada.
  • Memória, tratamento de erros e status de inicialização segura são sempre verificados.
  • Alerta poderoso; Inclui chip, estrutura, sensor, protocolo, pino e restrições.

Tarefa de aplicativo

Escolha um sensor (por exemplo, DS18B20, MPU6050 ou HC-SR04) e um microcontrolador (Arduino/ESP32/STM32). Faça com que a IA gere um código de leitura sem bloqueio com o poderoso modelo de prompt nesta unidade. Em seguida, siga os sete itens da lista de verificação de revisão, um por um: compare pelo menos um valor de registro/pino com a folha de dados, verifique se há atrasos de loop, verifique o status volátil das variáveis ​​compartilhadas. Quantos itens foram aprovados na primeira tentativa e quantos exigiram correção? Anote cada problema que encontrar e sua solução.

Antigo Próximo