U-BLOX NINA W102 e ESP-IDF (WINDOWS) COM ECLIPSE

O objetivo deste BLOG é demonstrar como é possível utilizar o ESP-IDF para programar o módulo U-BLOX NINA W com framework SDK ESP-IDF pelo WINDOWS via ECLIPSE. Foi utilizado o EVK-NINA-W para o teste.

Funcionou muito bem no WINDOWS 7 e WINDOWS 10

ATENÇÃO

Habilite esta opção antes de compilar! Mudança a partir do ESP-IDF 4.0.1

Criei um arquivo chamado

partitions_mine.csv com o seguinte conteudo

nvs, data, nvs, , 0x6000,

phy_init, data, phy, , 0x1000,

factory, app, factory, , 1M,

Ao utilizar o menuconfig, nao esquecer de copiar sdkconfig para sdkconfig.defaults. Partitions_Mine.csv deve estar na pasta root de seu projeto

ECLIPSE

Eclipse é uma IDE para desenvolvimento Java, porém suporta várias outras linguagens a partir de plugins como C/C++,PHP,ColdFusion, Python, Scala e Kotlin. Ele foi feito em Java e segue o modelo open source de desenvolvimento de software.

ESP-IDF

Ferramentas de instalação do ESP-IDF

https://dl.espressif.com/dl/esp-idf-tools-setup-2.3.exe

O instalador inclui a ferramenta de compilação cross-compiladores, OpenOCD, cmake e Ninja. O instalador também pode baixar e executar instaladores do Python 3.7 e Git For Windows, se ainda não estiverem instalados no computador.

O instalador também oferece o download de uma das versões do ESP-IDF.

Utilizando o Prompt de Comando

Demais operações requer uso do Prompt de Comandos

O Instalador de ferramentas do ESP-IDF cria um atalho no menu Iniciar para iniciar o prompt de comando do ESP-IDF. Este atalho inicia o prompt de comando (cmd.exe) e executa o script export.bat para configurar as variáveis de ambiente (PATH, IDF_PATH e outras). Dentro deste prompt de comando, todas as ferramentas instaladas estão disponíveis.

Observe que esse atalho é específico ao diretório ESP-IDF selecionado no Instalador de ferramentas ESP-IDF. Se você tiver vários diretórios ESP-IDF no computador (por exemplo, para trabalhar com versões diferentes do ESP-IDF), você terá duas opções para usá-los:

Crie uma cópia do atalho criado pelo instalador de ferramentas do ESP-IDF e altere o diretório de trabalho do novo atalho para o diretório do ESP-IDF que você deseja usar.

Como alternativa, execute cmd.exe, mude para o diretório ESP-IDF que você deseja usar e execute export.bat. Observe que, diferentemente da opção anterior, dessa maneira, o Python e o Git precisam estar presentes no PATH. Se você não encontrar erros relacionados ao Python ou ao Git, use a primeira opção.

Iniciando um projeto

Agora você está pronto para preparar seu aplicativo para o ESP32. Você pode começar com o projeto get-begin / hello_world no diretório examples no ESP-IDF

crie um pasta c:\esp

Copie o projeto hello_world para dentro desta pasta

Há uma variedade de exemplos de projetos no diretório de exemplos no ESP-IDF. Você pode copiar qualquer projeto da mesma maneira apresentada acima e executá-lo.

Também é possível criar exemplos no local, sem copiá-los primeiro.

Importante

O sistema de construção do ESP-IDF não suporta espaços nos caminhos do ESP-IDF ou dos projetos.

Conecte com seu Device

Descubra a COM onde esta conectado seu EVK-NINA-W.

Configure

Navegue para o diretório hello_world a partir da Etapa acima. Inicie um Projeto, defina o chip ESP32 como o destino e execute o utilitário de configuração do projeto menuconfig.

Execute idf.py menuconfig

Selecione ESP32 com 2MB e também a COM

Compile

idf.py build

Este comando compilará o aplicativo e todos os componentes do ESP-IDF e, em seguida, gerará o carregador de inicialização, a tabela de partição e os binários do aplicativo.

Se não houver erros, a construção será concluída gerando o arquivo .bin binário do firmware.

Gravando

Atualize os binários que você acabou de criar na sua placa ESP32 executando:

idf.py -p PORT [-b BAUD] flash

Substitua PORT pelo nome da porta serial da placa ESP32. Conecte seu dispositivo.

Você também pode alterar a taxa de transmissão do pisca-pisca substituindo BAUD pela taxa de transmissão necessária. A taxa de transmissão padrão é 460800.

idf.py -p 78 flash

Execução

idf.py -p COM78 monitor

Então reset o EVK-NINA-W

Um icone de atalho será criado para criar o ambiente para compilar a sua aplicação!

Click no icone e vá para pasta onde está o teu projeto!

E então digite:

idf.py build

para compilar

A imagem abaixo mostra como compilar o exemplo do BLINK, execute menuconfig antes

Então pode executar o comando

idf.py -p 78 flash

Compilando no LINUX

O procedimento é muito parecido com o WINDOWS. Siga o link da espressif!

Requer conhecimento básico do LINUX! Deves dar permissão para a SERIAL e foi utilizado o UBUNTU 18 e versão ESP-IDF 4.0.1

https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/index.html#get-started-get-esp-idf

Testes com o exemplo abaixo com sucesso no Windows e Linux!

/* Blink Example
   This example code is in the Public Domain (or CC0 licensed, at your option.)
   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "sdkconfig.h"

/* Can run 'make menuconfig' to choose the GPIO to blink,
   or you can edit the following line and set a number here.
*/
#define BLINK_GPIO 23  //nina w gpio (LED)

void blink_task(void *pvParameter)
{
    /* Configure the IOMUX register for pad BLINK_GPIO (some pads are
       muxed to GPIO on reset already, but some default to other
       functions and need to be switched to GPIO. Consult the
       Technical Reference for a list of pads and their default
       functions.)
    */
    gpio_pad_select_gpio(BLINK_GPIO);
    /* Set the GPIO as a push/pull output */
    gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);
    while(1) {
        /* Blink off (output low) */
        gpio_set_level(BLINK_GPIO, 0);
        vTaskDelay(1000 / portTICK_PERIOD_MS);
        /* Blink on (output high) */
        gpio_set_level(BLINK_GPIO, 1);
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main()
{
    xTaskCreate(&blink_task, "blink_task", configMINIMAL_STACK_SIZE, NULL, 5, NULL);
}

USANDO O ECLIPSE

Após seguir o procedimentos acima e conseguires compilar e gravar, siga o roteiro abaixo:

https://github.com/espressif/idf-eclipse-plugin, muito menos dor de cabeça. :)

Testei o exemplo BLINK

Tradução de

https://github.com/espressif/idf-eclipse-plugin

Instalando pré-requisitos

Java 8 e superior : faça o download e instale o Java SE a partir daqui
Python 3.5 e superior : Baixe e instale o Python a partir daqui
Eclipse 2018-12 CDT e superior : Faça o download e instale o pacote Eclipse CDT a partir daqui
Git : Obtenha o último git daqui
ESP-IDF 4.0 e superior : clone o repositório ESP-IDF a partir daqui

Nota: Verifique se Java, Python e Git estão disponíveis no PATH do ambiente do sistema.

Instalando plug-ins IDF usando a URL do site de atualização

É possível instalar os plug-ins IDF Eclipse em uma instalação existente do Eclipse CDT usando a URL do site de atualização. Primeiro, você precisa adicionar o URL do repositório da versão da seguinte maneira:

Vá para Help->Install New Software
Clique Add…
Digite Locationo repositório https://dl.espressif.com/dl/idf-eclipse-plugin/updates/latest/
Digite NamecomoEspressif IDF Plugins for Eclipse
Clique Ok
Selecione Espressif IDFna lista e continue com a instalação

Instalando ferramentas ESP-IDF

O ESP-IDF requer a instalação de algumas ferramentas de pré-requisito para que você possa construir o firmware para o ESP32. As ferramentas de pré-requisito incluem Python, Git, compiladores cruzados, ferramenta menuconfig, ferramentas de construção CMake e Ninja.

Para este guia de primeiros passos, siga as instruções abaixo.

Navegue até Help> Espressif IDF Tools Manager>Install Tools
Forneça o ESP-IDF Directorycaminho
Fornecer Gite Pythonlocais executáveis se eles não são detectados automaticamente.
Clique em Install Toolspara continuar com o processo de instalação. Verifique o console para obter os detalhes da instalação.
A instalação pode demorar um pouco, se você estiver fazendo isso pela primeira vez, pois precisa baixar e instalar as ferramentas xtensa-esp32-elf, esp32ulp-elf, cmake, openocd-esp32 e ninja.

Nota: Certifique-se de executar esta etapa mesmo se você já instalou as ferramentas necessárias, pois ela define IDF_PATH, PATH, OPENOCD_SCRIPTS e IDF_PYTHON_ENV_PATH para o ambiente de construção do Eclipse CDT com base no comando de exportação idf_tools.py.

Caixa de diálogo de seleção do diretório ESP-IDF:

Crie um novo projeto

Verifique se você está em C/C++ Perspective
Ir para File> New> Espressif IDF Project(Se você não vê isso, reajuste a perspectiva de Window> Perspective> Reset Perspective..)
Proporciona a Project name
Clique Finish

Crie um novo projeto usando modelos ESP-IDF

Verifique se você está dentro C/C++ Perspective
Ir para File> New> Espressif IDF Project(Se você não vê isso, reajuste a perspectiva de Window> Perspective> Reset Perspective..)
Proporciona a Project name
Clique Next
Verifica Create a project using one of the templates
Selecione o modelo necessário na árvore
Clique Finish

Configurando o destino de inicialização

Em seguida, precisamos dizer à CDT para usar a cadeia de ferramentas em nosso projeto, para que todos os cabeçalhos sejam indexados e resolvidos. Isso é feito através da Barra de Ativação, o novo conjunto de widgets que você vê na extrema esquerda da barra de ferramentas. Isso será mostrado apenas quando você tiver um projeto no explorador de projetos.

Clique no terceiro menu suspenso
Selecione New Launch Target
Selecione ESP Target
Forneça propriedades para o destino em que você deseja iniciar o aplicativo. Digite a Namepara o destino e selecione o Serial Portdispositivo ESP conectado ao seu equipamento.

Compilando o projeto

Selecione um projeto no Project Explorer
Selecione Runno primeiro menu suspenso, chamadoLaunch Mode
Selecione seu aplicativo no segundo menu suspenso, chamado Launch Configuration(Detectado automaticamente)
Selecione o destino no terceiro menu suspenso, chamado Launch Target
Agora clique no Buildwidget de botão que você vê na extrema esquerda da barra de ferramentas

Gravando o projeto

O ESP-IDF possui uma ferramenta chamada idf.pywrapper ao redor do comando make flash com algumas operações úteis. A operação do flash pode ser iniciada com apenas um clique de um botão de inicialização (segundo botão da esquerda) e é configurada automaticamente para fazer o flash do aplicativo com o comando flash padrão, ou seja idf.py -p PORT flash,.

Para fornecer os argumentos personalizados do flash, siga este link para obter mais instruções.

Visualizando saída serial

Para ver a saída serial no Eclipse, precisamos configurar o terminal Eclipse para conectar-se à porta serial.

Clique no Open a Terminalícone na barra de ferramentas
Escolha Serial Terminalno menu suspenso do terminal
Selecione Serial Portpara o seu quadro. Exemplo:/dev/cu.SLAB_USBtoUART
Defina as configurações restantes e clique em Ok para iniciar o terminal Eclipse, que ouvirá a porta USB

Configurando o projeto

O plug-in IDF permitirá que você configure sdkconfigsem sair do ambiente Eclipse.

Editor de configuração do SDK

A configuração do projeto é mantida em um único arquivo chamado sdkconfigno diretório raiz do projeto. Este arquivo de configuração pode ser modificado usandoSDK Configuration Editor

Para iniciar o editor de configuração do SDK:

Navegue para o sdkconfigarquivo
Clique duas vezes no arquivo para iniciar o editor de configuração do SDK
Use Ctrl+Sou com Command+Sbase no ambiente do SO para salvar as alterações. Você também pode usar o Savebotão Eclipse na barra de ferramentas
Para reverter as alterações do editor sdkconfig, você pode fechar o editor sem salvá-las ou clicar com o botão direito do mouse no sdkconfigarquivo e selecionar a Load sdkconfigopção de menu para reverter as alterações do editor.

CMake Editor

O plug-in do CMake Editor é integrado aos plug-ins do IDF para editar arquivos do CMake, como o CMakeLists.txt. Ele fornece cores de sintaxe, assistente de conteúdo de comando do CMake e modelos de código.

As preferências do editor CMake podem ser controladas usando Eclipse > Preferences > CMakeEd

Depurando o Projeto

Consulte o guia de depuração JTAG

Arquivos de configuração de inicialização de depuração predefinidos podem ser encontrados aqui . Estes podem ser usados para referência.

Consulte a seção Importando a configuração de inicialização de depuração para importar os arquivos de configuração existentes no Eclipse. Certifique-se de modificar as configurações específicas do projeto de configuração de ativação por depuração após a importação.

Configurando variáveis de ambiente

Eclipse auto configura as variáveis de ambiente requeridas na Preferences > C/C++ Build > Environmentseção se Tools IDF são instalados usando Help> Espressif IDF Tools Manager> Install Toolsopção do menu.

Variáveis de ambiente necessárias:

IDF_PATH
CAMINHO
OPENOCD_SCRIPTS
IDF_PYTHON_ENV_PATH

Se as variáveis de ambiente necessárias não estiverem configuradas por qualquer motivo, siga as instruções passo a passo abaixo.

Clique na Environmentpágina de preferências abaixo C/C++ Build.
Clique em "Adicionar ..." novamente e digite o nome IDF_PATH. O valor deve ser o caminho completo em que o ESP-IDF está instalado.
Da mesma forma, devemos configurar as variáveis de ambiente OPENOCD_SCRIPTS, IDF_PYTHON_ENV_PATH e PATH

É assim que eles devem ficar:

IDF_PATH

/Users/kondal/esp/esp-idf

OPENOCD_SCRIPTS

/Users/kondal/.espressif/tools/openocd-esp32/v0.10.0-esp32-20190313/openocd-esp32/share/openocd/scripts

IDF_PYTHON_ENV_PATH

/Users/kondal/.espressif/python_env/idf4.0_py3.7_env

CAMINHO

/Users/kondal/.espressif/tools/xtensa-esp32-elf/esp32-2019r1-8.2.0/xtensa-esp32-elf/bin:/Users/kondal/.espressif/tools/esp32ulp-elf/2.28.51.20170517/esp32ulp-elf-binutils/bin:/Users/kondal/.espressif/tools/cmake/3.13.4/CMake.app/Contents/bin:/Users/kondal/.espressif/tools/openocd-esp32/v0.10.0-esp32-20190313/openocd-esp32/bin:/Users/kondal/.espressif/tools/ninja/1.9.0/:/Users/kondal/.espressif/python_env/idf4.0_py3.7_env/bin:/Users/kondal/esp/esp-idf/tools:$PATH

No caminho acima, o último segmento $PATHprecisa ser substituído pelo PATH do ambiente do sistema com base no sistema operacional. Por exemplo, para obter o PATH do ambiente do sistema.

No macOS, $echo $PATH
No Windows, $echo %PATH%

Configurando cadeias de ferramentas

Precisamos dizer ao Eclipse CDT que cadeia de ferramentas de construção central e de cadeia de ferramentas CMake precisam ser usadas para construir o projeto. No entanto, isso será detectado automaticamente se você instalou as ferramentas usando a Help > Espressif IDF Tools Manager > Install Toolsopção do Eclipse.

Se essas cadeias de ferramentas não forem detectadas por qualquer motivo, siga as instruções passo a passo abaixo para adicionar uma nova cadeia de ferramentas.

Configurando cadeias de ferramentas de compilação principais

Abra Preferências do Eclipse
Navegue para a C/C++ -> “Core Build Toolchainspágina de preferências
Clique nas Add..tabelas Toolchians definidas pelo usuário
Selecione GCCcomo um tipo de cadeia de ferramentas
Clique em Next>
Forneça as configurações de cadeia de ferramentas do GCC:

Compilador: / Usuários / kondal / esp / xtensa-esp32-elf / bin / xtensa-esp32-elf-gcc, Sistema operacional: esp32, arquitetura da CPU: xtensa

Configurando o CMake Toolchain

Agora precisamos informar à CDT qual cadeia de ferramentas usar ao criar o projeto. Isso passará os argumentos necessários para o CMake ao gerar os arquivos Ninja.

Navegue para a página de preferências "C / C ++ ->" CMake "
Clique Add..e isso abrirá o diálogo de configuração do New CMake Toolchain
Navegue pelo toolchain do CMake Path. Exemplo:/Users/kondal/esp/esp-idf/tools/cmake/toolchain-esp32.cmake
Selecione o compilador GCC Xtensa Toolchain na lista suspensa. Exemplo:esp32 xtensa /Users/kondal/esp/xtensa-esp32-elf/bin/xtensa-esp32-elf-gcc

NOTA: O Eclipse CDT tem um erro ao salvar as preferências da cadeia de ferramentas, portanto, é recomendável reiniciar o Eclipse antes de avançarmos na configuração do destino de inicialização.

Iniciar configuração

Para fornecer a configuração de inicialização personalizada e os argumentos do flash, siga as instruções passo a passo abaixo.

Clique no Launch Configurationbotão editar
Mudar para o Mainseparador
Especifique Locationonde esse aplicativo deve ser executado. Como idf.pyé um arquivo python, irá configurar o caminho do sistema python. Exemplo:${system_path:python}
Especifique Working directoryo aplicativo. Exemplo:${workspace_loc:/hello_world}
Em argumentos adicionais, forneça um comando intermitente que será executado no diretório de trabalho especificado
O comando Flash fica assim: /Users/kondal/esp/esp-idf/tools/idf.py -p /dev/cu.SLAB_USBtoUART flash
Clique em OK para salvar as configurações
Clique no Launchícone para atualizar o aplicativo para o painel selecionado

Solução de problemas

Log de erros

A visualização Log de Erros captura todos os avisos e erros registrados pelos plug-ins. O arquivo de log subjacente é um arquivo .log armazenado no subdiretório .metadata da área de trabalho.

A visualização Log de erros está disponível em Window > Show View > Error Log.

Para exportar o conteúdo atual da exibição de log em um arquivo, pressione o botão Exportar barra de ferramentas ou selecione Export Log...no menu de contexto. Em seguida, insira um nome de arquivo.

Sempre forneça um log de erros ao relatar um problema.

Log de exibição do console

A Visualização do console fornece todos os avisos e erros relacionados ao processo ou à construção atual. Para acessar a visualização do console.

Na barra de menus Window > Show View > Console,.

CDT Global Build Log

Vamos para Preferences > C/C++ > Build > Logging

Console de ferramentas Espressif IDF

O Espressif IDF Tools Console faz parte da visualização Console, ele será aberto apenas durante a instalação das ferramentas IDF a partir do Eclipse.

Se você encontrar algum problema ao instalar as ferramentas IDF Help > Espressif Tools Manager > Install tools, verifique o Espressif IDF Tools Console para ver os erros relatados.

Se isso não estiver ativo, pode ser alternado clicando no Display Selected Consoleícone na visualização do console.

Instalando plug-ins IDF a partir do arquivo local

Faça o download do arquivo de atualização mais recente do site para os IDF Eclipse Plugins aqui - https://github.com/espressif/idf-eclipse-plugin/releases
No Eclipse, escolha Help->Install New Software
Clique Add… botão
Selecione Archivena caixa de diálogo Adicionar repositório e selecione o arquivocom.espressif.idf.update-vxxxxxxx.zip
Clique Add
Selecione Espressif IDFna lista e continue com a instalação
Reinicie o Eclipse

Como atualizo meus plug-ins IDF Eclipse existentes?

Se você estiver instalando IDF Eclipse Plugins no Eclipse pela primeira vez, primeiro precisará adicionar o repositório da nova versão da seguinte maneira:

Janela> Preferências> Instalar / Atualizar> Sites de Software Disponíveis
Clique Add
Digite o URL do novo repositório https://dl.espressif.com/dl/idf-eclipse-plugin/updates/latest/
Clique Ok

Se você já instalou os IDF Eclipse Plugins usando a URL do site de atualização, poderá obter as alterações mais recentes usando abaixo

Ajuda> Verificar atualizações
Se forem encontradas atualizações, selecione Espressif IDF Plugins for Eclipsee desmarque todos os outros itens
Clique Nextpara continuar com a instalação

Importando um Projeto IDF existente

Certifique-se de que você está em C/C++ Perspective.
Clique com o botão direito do mouse no Project Explorer
Selecione Import..Menu
Selecionar Existing IDF ProjectentreEspressif lista de menus do assistente de importação
Clique Next
Clique em Browse...para escolher um diretório de localização do projeto existente
Forneça Project namese você deseja um nome diferente
Clique Finishpara importar o projeto selecionado para a área de trabalho do eclipse como um projeto do CMake

Importando uma configuração de inicialização de depuração existente

Para importar uma configuração de ativação existente para o Eclipse:

Selecione Import...no Filemenu
Na caixa de diálogo Importar, expanda o Run/Debuggrupo e selecioneLaunch Configurations
Clique em Next
Clique em Browse... para selecionar o local necessário no sistema de arquivos local
Selecione a pasta que contém os arquivos de inicialização e clique em OK
Marque as caixas de seleção da pasta necessária e inicie o arquivo
Se você estiver substituindo uma configuração existente com o mesmo nome, selecione Overwrite existing launch configurations without warning
Clique em Finish

FONTES: