Placa de interface universal incorporada - Controle USB / Bluetooth / WIFI: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Costumo descobrir que crio bibliotecas para novos módulos incorporados do zero com base na folha de dados do dispositivo. Ao gerar a biblioteca, descobri que fico preso em um ciclo de código, compilação, programa e teste ao garantir que as coisas funcionem e estejam livres de bugs. Freqüentemente, os tempos de compilação e programa podem ser muito maiores do que o tempo que leva para editar o código e, portanto, uma maneira de cortar essas etapas durante o desenvolvimento seria muito útil.

Freqüentemente, também acho que quero fazer a interface de um módulo incorporado com um PC. Se o módulo não tiver especificamente uma conexão USB, o que geralmente acontece, você geralmente terá que comprar um conversor USB caro que fará um único trabalho, como apenas SPI ou apenas I2C.

É por essas razões que decidi criar a placa de interface universal. Ele foi projetado para permitir comunicações fáceis baseadas em PC com módulos incorporados.

Os recursos de interface incorporados da placa que decidi incluir.

• E / S digital
• I2C
• SPI
• UART
• PWM
• Servo motor
• Entrada ADC
• Saída DAC

Tudo isso pode ser usado de forma totalmente independente.

A placa de interface pode ser controlada por meio de uma conexão USB ao PC, mas também possui conexões de módulo WIFI ou Bluetooth opcionais para permitir que a placa seja usada remotamente ou em um cenário do tipo IoT.

Usando cabeçotes SIL de passo de 2,54 mm padrão, é possível conectar diretamente cabos duplos fêmea entre a placa e o módulo embutido, permitindo conexões rápidas, confiáveis e sem solda.

Também pensei em adicionar coisas como CAN, LIN, H-bridge etc, mas isso pode vir mais tarde com uma revisão v2.

Etapa 1: Projetando o PCB

Ao projetar o PCB, gosto de tentar manter as coisas o mais simples possível. Quando você vai construir placas à mão, é importante adicionar componentes apenas quando eles têm uma finalidade específica e usar o máximo possível de recursos internos do microcontrolador.

Olhando para o meu fornecedor de eletrônicos preferido, encontrei um chip com o qual me sentia confortável, que tinha os recursos que eu procurava e tinha um custo razoável. O chip em que caí foi o PIC18F24K50.

Com os 23 pinos de I / O disponíveis, isso me permitiu esses recursos

• Digtal I / O
• I2C
• SPI
• UART
• PWM x 2
• Servo motor x 6
• Entrada ADC x 3
• Saída DAC x 1
• I / O conduzido de 5V ou 3V3
• LED de status

Uma desvantagem do IC que escolhi é que ele tem apenas um periférico UART e, portanto, usar o método de controle Bluetooth ou Wifi impedirá que você seja capaz de usar a conexão UART.

As imagens acima mostram o esquema acabado e o PCB.

Etapa 2: Projetando o protocolo

A primeira etapa no projeto do protocolo é decidir o que especificamente você precisará que a placa seja capaz de fazer. Dividir as coisas adiciona um melhor nível de controle, enquanto combinar as coisas simplifica a interface e reduz o tráfego de comunicação entre a placa e o PC. É um jogo de equilíbrio e difícil de aperfeiçoar.

Para cada função da placa você deve indicar quaisquer parâmetros e retornos. Por exemplo, uma função para ler uma entrada ADC pode ter um parâmetro para especificar qual entrada amostrar e um valor de retorno contendo o resultado.

Em meu projeto, aqui está a lista de funções que eu queria incluir:

• E / S digital

  • SetPin (PinNumber, State)
  • State = GetPin (PinNumber)

• SPI

  • Inicializar (modo SPI)
  • DataIn = Transfer (DataOut)
  • ControlChipSelect (Canal, Estado)
  • SetPrescaler (taxa)

• I2C

  • Inicializar ()
  • Começar ()
  • Reiniciar ()
  • Pare ()
  • SlaveAck = Enviar (DataOut)
  • DataIn = Receber (Último)

• UART

  • Inicializar ()
  • Byte TX (DataOut)
  • BytesAvailable = RX Count ()
  • DataIn = RX Byte ()
  • SetBaud (Baud)

• PWM

  • Habilitar (Canal)
  • Desativar (Canal)
  • SetFrequency (canal, frequência)
  • GetMaxDuty (Duty)
  • SetDuty (Duty)

• Servo

  • Habilitar (Canal)
  • Desativar (Canal)
  • SetPosition (canal, posição)

• ADC

  ADCsample = Amostra (Canal)

• DAC

  • Permitir
  • Desabilitar
  • SetOutput (Voltagem)

• WI-FI

  • SetSSID (SSID)
  • Definir senha (senha)
  • Status = CheckConnectionStatus ()
  • IP = GetIPAddress ()

Os parâmetros são mostrados entre colchetes e os retornos são mostrados antes do símbolo de igual.

Antes de começar a codificar, atribuo a cada função um código de comando começando em 128 (binário 0b10000000) e trabalhando para cima. Documento totalmente o protocolo para garantir que, assim que minha cabeça estiver no código, eu tenha um bom documento para consultar. O documento de protocolo completo para este projeto está anexado e inclui códigos de comando de entrada e larguras de bits.

Etapa 3: projetar o firmware

Uma vez estabelecido o protocolo, é necessário implementar a funcionalidade no hardware.

Eu adoto uma abordagem de tipo de máquina de estado simples ao desenvolver sistemas escravos para tentar maximizar o comando potencial e a taxa de transferência de dados enquanto mantenho o firmware simples de entender e depurar. Um sistema mais avançado, como o Modbus, pode ser usado se você precisar de uma melhor interação com outros dispositivos conectados, mas isso adiciona sobrecarga, o que tornará as coisas mais lentas.

A máquina de estado consiste em três estados:

1) Esperando por comandos

2) Parâmetros de recepção

3) Responder

Os três estados interagem da seguinte forma:

1) Percorremos os bytes de entrada no buffer até que tenhamos um byte que tenha o conjunto de bits mais significativo. Assim que recebemos esse byte, comparamos com uma lista de comandos conhecidos. Se encontrarmos uma correspondência, atribuímos o número de bytes de parâmetro e retornamos bytes para corresponder ao protocolo. Se não houver bytes de parâmetro, podemos executar o comando aqui e pular para o estado 3 ou reiniciar o estado 1. Se houver bytes de parâmetro, passamos para o estado 2.

2) Percorremos os bytes de entrada salvando-os até armazenar todos os parâmetros. Assim que tivermos todos os parâmetros, executamos o comando. Se houver bytes de retorno, passamos para o estágio 3. Se não houver bytes de retorno para enviar, retornamos ao estágio 1.

3) Passamos pelos bytes de entrada e, para cada byte, sobrescrevemos o byte de eco com um byte de retorno válido. Depois de enviar todos os bytes de retorno, retornamos ao estágio 1.

Usei o Flowcode para projetar o firmware, pois ele demonstra visualmente o que estou fazendo. A mesma coisa poderia ser feita igualmente bem no Arduino ou em outras linguagens de programação incorporadas.

O primeiro passo é estabelecer comunicação com o PC. Para fazer isso, o micro precisa ser configurado para funcionar na velocidade certa e temos que adicionar o código para acionar os periféricos USB e UART. No Flowcode, isso é tão fácil quanto arrastar para o projeto um componente USB Serial e um componente UART do menu do componente Comms.

Adicionamos uma interrupção RX e um buffer para capturar os comandos de entrada no UART e verificamos regularmente o USB. Podemos então processar o amortecedor em nosso lazer.

O projeto Flowcode e o código C gerado estão anexados.

Etapa 4: interface via código de fluxo

A simulação do Flowcode é muito poderosa e nos permite criar um componente para falar com a placa. Ao criar o componente, agora podemos simplesmente arrastar o componente para o nosso projeto e ter instantaneamente as funções da placa disponíveis. Como um bônus adicional, qualquer componente existente que tenha um periférico SPI, I2C ou UART pode ser usado na simulação e os dados de comunicação podem ser canalizados para a placa de interface por meio de um componente injetor. As imagens anexadas mostram um programa simples para imprimir uma mensagem no visor. Os dados de comunicação que são enviados por meio da placa de interface para o hardware de exibição real e a configuração do componente com o display I2C, o injetor I2C e os componentes da placa de interface.

O novo modo SCADA para Flowcode 8.1 é um bônus adicional absoluto, pois podemos pegar um programa que faz algo no simulador Flowcode e exportá-lo para que seja executado sozinho em qualquer PC, sem problemas de licenciamento. Isso pode ser ótimo para projetos como plataformas de teste ou clusters de sensores.

Eu uso este modo SCADA para criar a ferramenta de configuração WIFI que pode ser usada para configurar o SSID e a senha, bem como coletar o endereço IP do módulo. Isso me permite configurar tudo usando a conexão USB e, em seguida, transferir para uma conexão de rede WIFI quando tudo estiver funcionando.

Alguns exemplos de projetos estão anexados.

Etapa 5: Outros métodos de interface

Assim como o Flowcode, você pode usar a linguagem de programação de sua escolha para se comunicar com a placa de interface. Usamos o Flowcode porque ele já tinha uma biblioteca de peças que poderíamos colocar em funcionamento imediatamente, mas isso também se aplica a muitas outras linguagens.

Aqui está uma lista de idiomas e métodos para se comunicar com a placa de interface.

Python - usando uma biblioteca serial para transmitir dados para uma porta COM ou endereço IP

Matlab - Usando comandos de arquivo para transmitir dados para uma porta COM ou endereço IP

C ++ / C # / VB - usando uma DLL pré-escrita, acessando diretamente a porta COM ou a API TCP / IP do Windows

Labview - usando uma DLL pré-escrita, o componente VISA Serial ou o componente TCP / IP

Se alguém quiser ver as linguagens acima implementadas, por favor, me avise.

Etapa 6: Produto Acabado

O produto acabado provavelmente será um recurso proeminente em meu kit de ferramentas integradas nos próximos anos. Já me ajudou a desenvolver componentes para vários visores e sensores Grove. Agora posso pegar o código completamente acertado antes de recorrer a qualquer compilação ou travessura de programação.

Já entreguei algumas placas para colegas para que eles possam melhorar o fluxo de trabalho também e foram muito bem recebidas.

Obrigado por ler meu Instructable, espero que você o tenha achado útil e que o inspire a criar suas próprias ferramentas para acelerar sua produtividade.