Arduino IDE: Criando placas personalizadas: 10 etapas

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

Nos últimos seis meses, passei muito tempo portando diferentes bibliotecas para a placa Robo HAT MM1 desenvolvida pela Robotics Masters. Isso levou a muitas descobertas sobre essas bibliotecas, como elas funcionam nos bastidores e, o mais importante, o que fazer para adicionar novas placas no futuro.

Este é o primeiro de uma série de artigos que estarei fazendo para ajudar outras pessoas que desejam portar bibliotecas para suas placas. Muitas das fontes de informação podem ser vagas ou difíceis de serem compreendidas por pessoas de fora. Espero ‘desmistificar’ e explicar como conseguir um porto de sucesso para todos.

Hoje, veremos a plataforma Arduino. Possui mais de 700.000 variantes de placas diferentes em todo o mundo e é uma das plataformas eletrônicas mais populares para a educação, indústria e fabricantes.

Só consegui encontrar fontes de informações muito limitadas sobre como fazer isso depois de muitas pesquisas no Google. Então, pensei em escrever sobre como fiz isso em detalhes.

Aqui vamos nós!

Etapa 1: antes de começar

Antes de começar a portar uma biblioteca de software ou firmware para sua placa, você deve saber alguns pontos-chave sobre a tecnologia que está usando e ser capaz de responder às perguntas abaixo.

1. Qual processador você está usando?
2. Que arquitetura ele usa?
3. Eu tenho acesso à folha de dados deste microprocessador?
4. Existe uma placa semelhante no mercado que usa o mesmo microprocessador?

Isso é muito importante. Isso terá impacto em muitos aspectos de como você aborda o processo de desenvolvimento.

As placas Arduino geralmente usam um número limitado de tipos de processadores e arquiteturas. O mais comum é a faixa ATMEGA usando a arquitetura AVR (Arduino Uno). Novas gerações de Arduinos estão se tornando mais comuns usando os processadores SAMD (ARM) e outros processadores mais poderosos. Portanto, é importante verificar qual você está usando.

A folha de dados de um microprocessador é absolutamente vital para garantir que a placa responda conforme o esperado quando você compila o firmware. Sem ele, você não poderá definir as funções de saída de pinos corretas ou configurar portas seriais.

Assim que tiver todas as informações de que precisa sobre o processador que está usando, você pode começar a examinar o software e modificá-lo para funcionar na sua placa personalizada.

Etapa 2: Visão geral

A parte mais difícil de qualquer projeto é encontrar um bom ponto de partida. Isso não é diferente. Lutei para encontrar bons tutoriais com detalhes suficientes sobre como criar placas personalizadas para o Arduino. A maioria dos tutoriais mostra como ‘adicionar um quadro personalizado’, mas não como ‘criar um quadro personalizado’. Aqui está um breve resumo do que está envolvido.

1. Baixe as definições de placa existentes e copie
2. Atualizando arquivos de definição (variant.h, varient.cpp)
3. Criar entrada do quadro (board.txt)
4. Atualizar versão da placa (platform.txt)
5. Preparando para instalação (json)
6. Instalando a placa no Arduino IDE

Cada etapa será explicada em detalhes abaixo. Haverá também uma ampla discussão sobre como cada arquivo interage entre si para ajudar a esclarecer como tudo funciona por trás do IDE do Arduino.

Neste tutorial, mostrarei como criar uma placa personalizada para processadores SAMD. Mais especificamente, o SAMD21G18A - que é o microprocessador usado na placa Robo HAT MM1 que eu estava portando.

Também presumo que você já tenha o Arduino IDE 1.8 ou posterior baixado. Eu usei o Arduino 1.8.9 no momento em que este artigo foi escrito.

Etapa 3: Baixar placas existentes

O primeiro passo é fazer o download da placa Arduino variante mais próxima que corresponda à sua placa. Para placas SAMD, este é o Arduino Zero.

Desde o Arduino IDE 1.6, o método para baixar novas placas no ambiente tem sido adicionando arquivos JSON especiais que os desenvolvedores de software fornecem e, em seguida, instalando as placas personalizadas usando o “Gerenciador de placas”. As versões anteriores do Arduino IDE usavam um método diferente que não discutiremos hoje. Estaremos criando nosso próprio arquivo JSON posteriormente neste tutorial, no entanto, precisamos adicionar a placa Arduino Zero usando este método primeiro.

Para nossa sorte, a placa que queremos baixar não precisa de um arquivo JSON porque o arquivo JSON vem pré-empacotado com o IDE do Arduino - então só precisamos instalar a placa a partir do “Gerenciador de placas”.

Para fazer isso, vá em “Ferramentas” e expanda o menu “Quadro”. No topo do menu “Board” estará o “Board Manager”. Clique nesta opção de menu para abrir o gerenciador de placas.

(Veja as imagens)

Quando o Boards Manager for aberto, ele examinará todos os arquivos JSON armazenados no IDE do Arduino e fará o download das configurações do arquivo. Você deve ver uma longa lista de placas Arduino disponíveis que podem ser instaladas.

(Veja as imagens)

Estamos interessados apenas na placa “Arduino SAMD Boards (32-bits ARM Cortex-M0 +)” para este tutorial, mas você pode desviar e instalar a placa de que precisa neste momento. Procure e instale a placa “Arduino SAMD Boards (32 bits ARM Cortex-M0 +)”. Isso pode ser feito clicando no texto da lista seguido do botão “Instalar” do lado direito que aparecerá após clicar no texto. A instalação demorará alguns minutos.

Para mais detalhes sobre a instalação de novas placas: A Adafruit tem um ótimo tutorial aqui que explica como instalar suas placas Feature M0.

Agora que os arquivos da placa foram instalados, podemos copiá-los para que possam ser modificados para sua placa personalizada.

Etapa 4: Localizando e copiando os arquivos da placa

No Windows, os arquivos do Board estão localizados em (lembre-se de alterar o nome de usuário para o seu nome de usuário):

C: / Users / username / AppData / Local / Arduino15 / packages

Nesta pasta, você tem que ir um pouco mais fundo para chegar aos arquivos que você precisa copiar para modificar. Para este tutorial, iremos obter os arquivos da placa Arduino Zero que serão instalados (lembre-se de alterar o nome de usuário para o seu nome de usuário):

C: / Users / username / AppData / Local / Arduino15 / packages / arduino / hardware / samd

Copie a pasta com número de versão localizada neste diretório para uma nova pasta em sua pasta Documentos ou pasta de sua escolha. Para os fins deste tutorial, irei colocá-los em uma nova pasta chamada ‘quadros personalizados’ dentro de Documentos.

A pasta contém várias pastas e diretórios. Os que usaremos estão indicados na tabela da imagem.

Etapa 5: Criação de variante

Agora estamos prontos para começar a criar uma entrada de placa personalizada. Para este tutorial, usarei o Robo HAT MM1 como exemplo. Como mencionado anteriormente, é uma placa baseada em SAMD que mais se assemelha à construção do Arduino Zero.

Começaremos indo para a pasta de variantes e copiando a pasta arduino_zero localizada lá. Vamos renomear a nova variante da placa de ‘robohatmm1’. Você pode chamar de seu como quiser.

(Veja a imagem)

Dentro da pasta robohatmm1 estarão os dois pinos que precisamos para começar a editar: variant.cpp e variant.h. Abra os dois.

Demorei um pouco para entender, então vou explicar aqui para economizar seu tempo. O arquivo variant.cpp contém uma grande variedade de pinos que são referenciados em variant.h. Todas as referências de pino em variant.h são uma referência à configuração de pino em uma posição particular na matriz variant.cpp.

(Veja a captura de tela com dois arquivos)

Portanto, a maioria das edições ocorrerá em ambos os arquivos, mas você precisa se certificar de que, se alterar a ordem dos pinos em variantes.cpp, você deverá alterar as referências no arquivo de cabeçalho (variantes.h). Para o Robo HAT MM1, eu só precisei mudar alguns dos pinos e funções. Isso foi feito em variantes.h. Eu adicionei alguns novos pinos PWM, já que o SAMD21 é capaz de lidar com 12 canais PWM. Também adicionei alguns nomes para Servos, Sinais (em vez de ADC / Digital) e mapeamento personalizado para as funções certas - como SPI, UART e I2C.

O importante a observar é verificar se as referências de array que você usa para as funções descritas em variantes.h correspondem ao pino em varaints.cpp - que veremos agora.

Variants.cpp é um arquivo muito poderoso e importante. Ele faz todo o trabalho árduo de definir os pinos para corresponder às configurações de hardware. A maneira mais fácil de explicar isso é com um exemplo e uma explicação de cada parte.

(Veja a tabela na captura de tela)

Exemplo (extrair de variantes.cpp)

{PORTA, 22, PIO_SERCOM, PIN_ATTR_NONE, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER, EXTERNAL_INT_NONE}, // SDA

Este é o primeiro pino na matriz variantes.cpp para o Robo HAT MM1. A tabela da folha de dados foi fornecida como uma imagem (tabela cinza).

(Veja as imagens)

Este pino específico é usado para a função de pino de dados I2C. Dando uma olhada na tabela, podemos ver que este pino pode ser usado como um pino I2C SDA (bom começo!). O pino é denominado “PA22”, que é a abreviação de PORTA no pino 22. Imediatamente podemos definir a PORTA e o número do pino para este pino.

A próxima coisa que precisamos fazer é definir o pino como uma porta de comunicação serial. O pino possui comunicação serial disponível através da função C (PIO_SERCOM) usando SERCOM 3 e D usando SERCOM5 (PIO_SERCOM_ALT). Para fins do Robo HAT MM1, estamos usando SERCOM3 para comunicação I2C. Isso está na Função C; também conhecido como. PIO_SERCOM para variantes.cpp.

Como planejamos usar este pino apenas como um SDA I2C, não há necessidade de definir nenhuma das outras funções. Todas elas podem ser definidas como opções “Não” ou “Não” da tabela anterior. No entanto, se quiséssemos usar as outras funções - poderíamos consultar a folha de dados e colocá-las nos espaços corretos. Está tudo na folha de dados.

A modificação dos arquivos variantes pode levar algum tempo. Tenha cuidado e sempre verifique três vezes.

Etapa 6: Criar uma definição de placa

Depois de ter seus arquivos variantes prontos, deve ser direto a partir daqui. A maior parte do trabalho será copiar e colar ou modificar e atualizar arquivos.

Começando com boards.txt.

(Veja a imagem)

Você vai querer copiar e colar uma definição de placa que já está lá. Eu recomendaria o Arduino Zero novamente.

Para simplificar, altere apenas o nome da placa (primeira linha), usb_product, usb_manufacturer e variante (robohat). Você pode personalizar os outros argumentos posteriormente para atender às suas necessidades - como um bootloader personalizado ou diferentes USB VID / PIDs para identificar sua placa.

A variante do tabuleiro deve corresponder ao nome dado à pasta criada no início. Para este tutorial, chamei-o de ‘robohatmm1’.

Também seria recomendável alterar a primeira parte de cada linha para corresponder ao nome do seu tabuleiro. Na captura de tela, ele foi alterado para ‘robo_hat_mm1’. Você deve escolher um nome para sua placa com o mesmo formato.

Isso é tudo para boards.txt, a menos que você queira fazer outras modificações mencionadas acima posteriormente.

Etapa 7: Atualizar a versão da placa

Em plataformas.txt, altere o nome para o nome de sua placa personalizada. Altere também o número da versão. Lembre-se de como você definiu isso, vamos precisar disso mais tarde.

Etapa 8: Criar arquivo de pacote JSON

Para instalar sua placa no Arduino IDE, você precisará criar um arquivo JSON que você importará. O arquivo JSON informa ao Arduino IDE onde obter os arquivos para instalar a placa, quais pacotes extras são necessários e alguns outros bits de metadados.

É muito importante que você salve este arquivo fora da pasta em que acabamos de trabalhar.

A maior parte do arquivo pode ser copiada e colada no seu. Você só precisará alterar a seção “placas” e os outros metadados na parte superior do arquivo. Veja a captura de tela para saber o que deve ser atualizado.

(Veja a imagem)

• Seção vermelha: são metadados que os usuários podem usar para encontrar ajuda. Tem muito pouca relevância técnica.
• Seção azul: tudo isso é importante. Eles são mostrados no IDE do Arduino. Nome, arquitetura e versão serão mostrados para qualquer pessoa que estiver tentando instalar o pacote. É aqui que você precisa colocar o número da versão em plataformas.txt. A segunda seção azul é a lista de placas incluídas no pacote. Você pode ter várias placas.
• Seção Verde: Esta seção precisa de mais explicações.

(Ver Tabela nas Imagens)

Depois de criar o arquivo zip, obter a soma de verificação do arquivo zip e o tamanho do arquivo, agora você pode fazer upload do arquivo zip para um local. Você precisará colocar esse URL no campo "url". Se o nome ou qualquer um dos detalhes acima estiverem incorretos, sua placa personalizada não será instalada.

Certifique-se de também enviar seu arquivo package_boardname_index.json para um local público na Internet. O GitHub é uma boa opção.

O arquivo da placa personalizada Robo HAT MM1 pode ser encontrado aqui.

Etapa 9: A etapa final - instale sua placa personalizada

Tudo indo bem, agora você deve ser capaz de incluir seu arquivo JSON no Arduino IDE e instalar sua placa personalizada.

Incluir o arquivo JSON é fácil! No IDE do Arduino - basta ir em “Arquivo”> “Preferências” e copiar e colar o local (URL) do seu package_boardname_index.json na seção “URLs adicionais do gerenciador de placas” na parte inferior do menu Preferências.

(Veja a imagem)

Em seguida, clique em OK.

Siga as instruções acima para instalar novas placas, caso tenha esquecido. Lembre-se de procurar sua placa personalizada desta vez!

(Veja a imagem)

Para mais detalhes sobre a instalação de novas placas: A Adafruit tem um ótimo tutorial aqui que explica como instalar suas placas Feature M0.

Etapa 10: Conclusão

Foi divertido criar placas Arduino personalizadas. Ainda há muito para eu experimentar no futuro (adicionar portas seriais), mas tem sido uma ótima experiência de aprendizado!

Certifique-se de verificar a campanha Crowd Supply também. Termina em 11 de junho de 2019.

www.crowdsupply.com/robotics-masters/robo-…

Espero que isso tenha ajudado você ou você tenha se divertido lendo junto!

Obrigado!